// Generated from ./TodoLangGrammar.g4 by ANTLR 4.9.0-SNAPSHOT


import { ATN } from "antlr4ts/atn/ATN";
import { ATNDeserializer } from "antlr4ts/atn/ATNDeserializer";
import { FailedPredicateException } from "antlr4ts/FailedPredicateException";
import { NotNull } from "antlr4ts/Decorators";
import { NoViableAltException } from "antlr4ts/NoViableAltException";
import { Override } from "antlr4ts/Decorators";
import { Parser } from "antlr4ts/Parser";
import { ParserRuleContext } from "antlr4ts/ParserRuleContext";
import { ParserATNSimulator } from "antlr4ts/atn/ParserATNSimulator";
import { ParseTreeListener } from "antlr4ts/tree/ParseTreeListener";
import { ParseTreeVisitor } from "antlr4ts/tree/ParseTreeVisitor";
import { RecognitionException } from "antlr4ts/RecognitionException";
import { RuleContext } from "antlr4ts/RuleContext";
//import { RuleVersion } from "antlr4ts/RuleVersion";
import { TerminalNode } from "antlr4ts/tree/TerminalNode";
import { Token } from "antlr4ts/Token";
import { TokenStream } from "antlr4ts/TokenStream";
import { Vocabulary } from "antlr4ts/Vocabulary";
import { VocabularyImpl } from "antlr4ts/VocabularyImpl";

import * as Utils from "antlr4ts/misc/Utils";

import { TodoLangGrammarListener } from "./TodoLangGrammarListener";

export class TodoLangGrammarParser extends Parser {
	public static readonly T__0 = 1;
	public static readonly T__1 = 2;
	public static readonly T__2 = 3;
	public static readonly T__3 = 4;
	public static readonly T__4 = 5;
	public static readonly T__5 = 6;
	public static readonly T__6 = 7;
	public static readonly T__7 = 8;
	public static readonly T__8 = 9;
	public static readonly T__9 = 10;
	public static readonly T__10 = 11;
	public static readonly T__11 = 12;
	public static readonly T__12 = 13;
	public static readonly T__13 = 14;
	public static readonly T__14 = 15;
	public static readonly T__15 = 16;
	public static readonly T__16 = 17;
	public static readonly T__17 = 18;
	public static readonly T__18 = 19;
	public static readonly OPER = 20;
	public static readonly OP = 21;
	public static readonly CELL = 22;
	public static readonly ORDER = 23;
	public static readonly BOOLEAN = 24;
	public static readonly COLON = 25;
	public static readonly COMMA = 26;
	public static readonly NULL = 27;
	public static readonly LeftP = 28;
	public static readonly RightP = 29;
	public static readonly COLUMN = 30;
	public static readonly STRING = 31;
	public static readonly AND = 32;
	public static readonly OR = 33;
	public static readonly INT = 34;
	public static readonly NUMBER = 35;
	public static readonly NOT = 36;
	public static readonly IDEN = 37;
	public static readonly LET = 38;
	public static readonly CHAR = 39;
	public static readonly DIG = 40;
	public static readonly CHINAMARKS = 41;
	public static readonly WS = 42;
	public static readonly NL = 43;
	public static readonly RULE_entry = 0;
	public static readonly RULE_expression = 1;
	public static readonly RULE_exprComposite = 2;
	public static readonly RULE_ternaryExpr = 3;
	public static readonly RULE_caseExpr = 4;
	public static readonly RULE_casePart = 5;
	public static readonly RULE_ifExpr = 6;
	public static readonly RULE_ifPart = 7;
	public static readonly RULE_elseIfPart = 8;
	public static readonly RULE_elsePart = 9;
	public static readonly RULE_block = 10;
	public static readonly RULE_exprBlock = 11;
	public static readonly RULE_returnExpr = 12;
	public static readonly RULE_expr = 13;
	public static readonly RULE_ifCondition = 14;
	public static readonly RULE_variableAssign = 15;
	public static readonly RULE_item = 16;
	public static readonly RULE_unit = 17;
	public static readonly RULE_variable = 18;
	public static readonly RULE_cellPosition = 19;
	public static readonly RULE_relativeCell = 20;
	public static readonly RULE_currentCellValue = 21;
	public static readonly RULE_currentCellData = 22;
	public static readonly RULE_cell = 23;
	public static readonly RULE_dataset = 24;
	public static readonly RULE_datasetColumn = 25;
	public static readonly RULE_function = 26;
	public static readonly RULE_functionParameter = 27;
	public static readonly RULE_set = 28;
	public static readonly RULE_cellCoordinate = 29;
	public static readonly RULE_coordinateLeft = 30;
	public static readonly RULE_coordinateTop = 31;
	public static readonly RULE_coordinate = 32;
	public static readonly RULE_cellIndicator = 33;
	public static readonly RULE_conditions = 34;
	public static readonly RULE_condition = 35;
	public static readonly RULE_property = 36;
	public static readonly RULE_currentValue = 37;
	public static readonly RULE_simpleValue = 38;
	public static readonly RULE_join = 39;
	public static readonly RULE_aggregate = 40;
	// tslint:disable:no-trailing-whitespace
	public static readonly ruleNames: string[] = [
		"entry", "expression", "exprComposite", "ternaryExpr", "caseExpr", "casePart", 
		"ifExpr", "ifPart", "elseIfPart", "elsePart", "block", "exprBlock", "returnExpr", 
		"expr", "ifCondition", "variableAssign", "item", "unit", "variable", "cellPosition", 
		"relativeCell", "currentCellValue", "currentCellData", "cell", "dataset", 
		"datasetColumn", "function", "functionParameter", "set", "cellCoordinate", 
		"coordinateLeft", "coordinateTop", "coordinate", "cellIndicator", "conditions", 
		"condition", "property", "currentValue", "simpleValue", "join", "aggregate",
	];

	private static readonly _LITERAL_NAMES: Array<string | undefined> = [
		undefined, "'?'", "'case'", "'{'", "'}'", "'if'", "'else'", "'return'", 
		"';'", "'var'", "'='", "'&'", "'$'", "'#'", "'.'", "'cell'", "'['", "']'", 
		"'to'", "'@'", undefined, undefined, undefined, undefined, undefined, 
		"':'", "','", "'null'", "'('", "')'", undefined, undefined, undefined, 
		undefined, undefined, undefined, "'!'",
	];
	private static readonly _SYMBOLIC_NAMES: Array<string | undefined> = [
		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
		undefined, undefined, undefined, undefined, undefined, undefined, "OPER", 
		"OP", "CELL", "ORDER", "BOOLEAN", "COLON", "COMMA", "NULL", "LeftP", "RightP", 
		"COLUMN", "STRING", "AND", "OR", "INT", "NUMBER", "NOT", "IDEN", "LET", 
		"CHAR", "DIG", "CHINAMARKS", "WS", "NL",
	];
	public static readonly VOCABULARY: Vocabulary = new VocabularyImpl(TodoLangGrammarParser._LITERAL_NAMES, TodoLangGrammarParser._SYMBOLIC_NAMES, []);

	// @Override
	// @NotNull
	public get vocabulary(): Vocabulary {
		return TodoLangGrammarParser.VOCABULARY;
	}
	// tslint:enable:no-trailing-whitespace

	// @Override
	public get grammarFileName(): string { return "TodoLangGrammar.g4"; }

	// @Override
	public get ruleNames(): string[] { return TodoLangGrammarParser.ruleNames; }

	// @Override
	public get serializedATN(): string { return TodoLangGrammarParser._serializedATN; }

	protected createFailedPredicateException(predicate?: string, message?: string): FailedPredicateException {
		return new FailedPredicateException(this, predicate, message);
	}

	constructor(input: TokenStream) {
		super(input);
		this._interp = new ParserATNSimulator(TodoLangGrammarParser._ATN, this);
	}
	// @RuleVersion(0)
	public entry(): EntryContext {
		let _localctx: EntryContext = new EntryContext(this._ctx, this.state);
		this.enterRule(_localctx, 0, TodoLangGrammarParser.RULE_entry);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 83;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			do {
				{
				{
				this.state = 82;
				this.expression();
				}
				}
				this.state = 85;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			} while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TodoLangGrammarParser.T__1) | (1 << TodoLangGrammarParser.T__4) | (1 << TodoLangGrammarParser.T__6) | (1 << TodoLangGrammarParser.T__8) | (1 << TodoLangGrammarParser.T__10) | (1 << TodoLangGrammarParser.T__11) | (1 << TodoLangGrammarParser.T__12) | (1 << TodoLangGrammarParser.T__14) | (1 << TodoLangGrammarParser.CELL) | (1 << TodoLangGrammarParser.BOOLEAN) | (1 << TodoLangGrammarParser.NULL) | (1 << TodoLangGrammarParser.LeftP) | (1 << TodoLangGrammarParser.STRING))) !== 0) || ((((_la - 34)) & ~0x1F) === 0 && ((1 << (_la - 34)) & ((1 << (TodoLangGrammarParser.INT - 34)) | (1 << (TodoLangGrammarParser.NUMBER - 34)) | (1 << (TodoLangGrammarParser.IDEN - 34)))) !== 0));
			this.state = 87;
			this.match(TodoLangGrammarParser.EOF);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public expression(): ExpressionContext {
		let _localctx: ExpressionContext = new ExpressionContext(this._ctx, this.state);
		this.enterRule(_localctx, 2, TodoLangGrammarParser.RULE_expression);
		try {
			this.state = 94;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 1, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 89;
				this.exprComposite(0);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 90;
				this.ifExpr();
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 91;
				this.caseExpr();
				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 92;
				this.returnExpr();
				}
				break;

			case 5:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 93;
				this.variableAssign();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}

	public exprComposite(): ExprCompositeContext;
	public exprComposite(_p: number): ExprCompositeContext;
	// @RuleVersion(0)
	public exprComposite(_p?: number): ExprCompositeContext {
		if (_p === undefined) {
			_p = 0;
		}

		let _parentctx: ParserRuleContext = this._ctx;
		let _parentState: number = this.state;
		let _localctx: ExprCompositeContext = new ExprCompositeContext(this._ctx, _parentState);
		let _prevctx: ExprCompositeContext = _localctx;
		let _startState: number = 4;
		this.enterRecursionRule(_localctx, 4, TodoLangGrammarParser.RULE_exprComposite, _p);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 103;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 2, this._ctx) ) {
			case 1:
				{
				_localctx = new SingleExprCompositeContext(_localctx);
				this._ctx = _localctx;
				_prevctx = _localctx;

				this.state = 97;
				this.expr();
				}
				break;

			case 2:
				{
				_localctx = new TernaryExprCompositeContext(_localctx);
				this._ctx = _localctx;
				_prevctx = _localctx;
				this.state = 98;
				this.ternaryExpr();
				}
				break;

			case 3:
				{
				_localctx = new ParenExprCompositeContext(_localctx);
				this._ctx = _localctx;
				_prevctx = _localctx;
				this.state = 99;
				this.match(TodoLangGrammarParser.LeftP);
				this.state = 100;
				this.exprComposite(0);
				this.state = 101;
				this.match(TodoLangGrammarParser.RightP);
				}
				break;
			}
			this._ctx._stop = this._input.tryLT(-1);
			this.state = 110;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 3, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					if (this._parseListeners != null) {
						this.triggerExitRuleEvent();
					}
					_prevctx = _localctx;
					{
					{
					_localctx = new ComplexExprCompositeContext(new ExprCompositeContext(_parentctx, _parentState));
					this.pushNewRecursionContext(_localctx, _startState, TodoLangGrammarParser.RULE_exprComposite);
					this.state = 105;
					if (!(this.precpred(this._ctx, 1))) {
						throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
					}
					this.state = 106;
					this.match(TodoLangGrammarParser.OPER);
					this.state = 107;
					this.exprComposite(2);
					}
					}
				}
				this.state = 112;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 3, this._ctx);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public ternaryExpr(): TernaryExprContext {
		let _localctx: TernaryExprContext = new TernaryExprContext(this._ctx, this.state);
		this.enterRule(_localctx, 6, TodoLangGrammarParser.RULE_ternaryExpr);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 113;
			this.ifCondition();
			this.state = 119;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === TodoLangGrammarParser.AND || _la === TodoLangGrammarParser.OR) {
				{
				{
				this.state = 114;
				this.join();
				this.state = 115;
				this.ifCondition();
				}
				}
				this.state = 121;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 122;
			this.match(TodoLangGrammarParser.T__0);
			this.state = 123;
			this.block();
			this.state = 124;
			this.match(TodoLangGrammarParser.COLON);
			this.state = 125;
			this.block();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public caseExpr(): CaseExprContext {
		let _localctx: CaseExprContext = new CaseExprContext(this._ctx, this.state);
		this.enterRule(_localctx, 8, TodoLangGrammarParser.RULE_caseExpr);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 127;
			this.match(TodoLangGrammarParser.T__1);
			this.state = 128;
			this.match(TodoLangGrammarParser.T__2);
			this.state = 129;
			this.casePart();
			this.state = 134;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === TodoLangGrammarParser.COMMA) {
				{
				{
				this.state = 130;
				this.match(TodoLangGrammarParser.COMMA);
				this.state = 131;
				this.casePart();
				}
				}
				this.state = 136;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 137;
			this.match(TodoLangGrammarParser.T__3);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public casePart(): CasePartContext {
		let _localctx: CasePartContext = new CasePartContext(this._ctx, this.state);
		this.enterRule(_localctx, 10, TodoLangGrammarParser.RULE_casePart);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 139;
			this.ifCondition();
			this.state = 145;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 6, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 140;
					this.join();
					this.state = 141;
					this.ifCondition();
					}
					}
				}
				this.state = 147;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 6, this._ctx);
			}
			this.state = 149;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 7, this._ctx) ) {
			case 1:
				{
				this.state = 148;
				this.match(TodoLangGrammarParser.COLON);
				}
				break;
			}
			this.state = 151;
			this.block();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public ifExpr(): IfExprContext {
		let _localctx: IfExprContext = new IfExprContext(this._ctx, this.state);
		this.enterRule(_localctx, 12, TodoLangGrammarParser.RULE_ifExpr);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 153;
			this.ifPart();
			this.state = 157;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 8, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 154;
					this.elseIfPart();
					}
					}
				}
				this.state = 159;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 8, this._ctx);
			}
			this.state = 161;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 9, this._ctx) ) {
			case 1:
				{
				this.state = 160;
				this.elsePart();
				}
				break;
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public ifPart(): IfPartContext {
		let _localctx: IfPartContext = new IfPartContext(this._ctx, this.state);
		this.enterRule(_localctx, 14, TodoLangGrammarParser.RULE_ifPart);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 163;
			this.match(TodoLangGrammarParser.T__4);
			this.state = 164;
			this.match(TodoLangGrammarParser.LeftP);
			this.state = 165;
			this.ifCondition();
			this.state = 171;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === TodoLangGrammarParser.AND || _la === TodoLangGrammarParser.OR) {
				{
				{
				this.state = 166;
				this.join();
				this.state = 167;
				this.ifCondition();
				}
				}
				this.state = 173;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 174;
			this.match(TodoLangGrammarParser.RightP);
			this.state = 175;
			this.match(TodoLangGrammarParser.T__2);
			this.state = 176;
			this.block();
			this.state = 177;
			this.match(TodoLangGrammarParser.T__3);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public elseIfPart(): ElseIfPartContext {
		let _localctx: ElseIfPartContext = new ElseIfPartContext(this._ctx, this.state);
		this.enterRule(_localctx, 16, TodoLangGrammarParser.RULE_elseIfPart);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 179;
			this.match(TodoLangGrammarParser.T__5);
			this.state = 180;
			this.match(TodoLangGrammarParser.T__4);
			this.state = 181;
			this.match(TodoLangGrammarParser.LeftP);
			this.state = 182;
			this.ifCondition();
			this.state = 188;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === TodoLangGrammarParser.AND || _la === TodoLangGrammarParser.OR) {
				{
				{
				this.state = 183;
				this.join();
				this.state = 184;
				this.ifCondition();
				}
				}
				this.state = 190;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 191;
			this.match(TodoLangGrammarParser.RightP);
			this.state = 192;
			this.match(TodoLangGrammarParser.T__2);
			this.state = 193;
			this.block();
			this.state = 194;
			this.match(TodoLangGrammarParser.T__3);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public elsePart(): ElsePartContext {
		let _localctx: ElsePartContext = new ElsePartContext(this._ctx, this.state);
		this.enterRule(_localctx, 18, TodoLangGrammarParser.RULE_elsePart);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 196;
			this.match(TodoLangGrammarParser.T__5);
			this.state = 197;
			this.match(TodoLangGrammarParser.T__2);
			this.state = 198;
			this.block();
			this.state = 199;
			this.match(TodoLangGrammarParser.T__3);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public block(): BlockContext {
		let _localctx: BlockContext = new BlockContext(this._ctx, this.state);
		this.enterRule(_localctx, 20, TodoLangGrammarParser.RULE_block);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 204;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 12, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 201;
					this.exprBlock();
					}
					}
				}
				this.state = 206;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 12, this._ctx);
			}
			this.state = 208;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 13, this._ctx) ) {
			case 1:
				{
				this.state = 207;
				this.returnExpr();
				}
				break;
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public exprBlock(): ExprBlockContext {
		let _localctx: ExprBlockContext = new ExprBlockContext(this._ctx, this.state);
		this.enterRule(_localctx, 22, TodoLangGrammarParser.RULE_exprBlock);
		try {
			this.state = 213;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case TodoLangGrammarParser.T__8:
			case TodoLangGrammarParser.IDEN:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 210;
				this.variableAssign();
				}
				break;
			case TodoLangGrammarParser.T__4:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 211;
				this.ifExpr();
				}
				break;
			case TodoLangGrammarParser.T__1:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 212;
				this.caseExpr();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public returnExpr(): ReturnExprContext {
		let _localctx: ReturnExprContext = new ReturnExprContext(this._ctx, this.state);
		this.enterRule(_localctx, 24, TodoLangGrammarParser.RULE_returnExpr);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 216;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === TodoLangGrammarParser.T__6) {
				{
				this.state = 215;
				this.match(TodoLangGrammarParser.T__6);
				}
			}

			this.state = 218;
			this.expr();
			this.state = 220;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 16, this._ctx) ) {
			case 1:
				{
				this.state = 219;
				this.match(TodoLangGrammarParser.T__7);
				}
				break;
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public expr(): ExprContext {
		let _localctx: ExprContext = new ExprContext(this._ctx, this.state);
		this.enterRule(_localctx, 26, TodoLangGrammarParser.RULE_expr);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 222;
			this.item();
			this.state = 227;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 17, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 223;
					this.match(TodoLangGrammarParser.OPER);
					this.state = 224;
					this.item();
					}
					}
				}
				this.state = 229;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 17, this._ctx);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public ifCondition(): IfConditionContext {
		let _localctx: IfConditionContext = new IfConditionContext(this._ctx, this.state);
		this.enterRule(_localctx, 28, TodoLangGrammarParser.RULE_ifCondition);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 230;
			this.expr();
			this.state = 231;
			this.match(TodoLangGrammarParser.OP);
			this.state = 232;
			this.expr();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public variableAssign(): VariableAssignContext {
		let _localctx: VariableAssignContext = new VariableAssignContext(this._ctx, this.state);
		this.enterRule(_localctx, 30, TodoLangGrammarParser.RULE_variableAssign);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 235;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === TodoLangGrammarParser.T__8) {
				{
				this.state = 234;
				this.match(TodoLangGrammarParser.T__8);
				}
			}

			this.state = 237;
			this.variable();
			this.state = 238;
			this.match(TodoLangGrammarParser.T__9);
			this.state = 239;
			this.expr();
			this.state = 241;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 19, this._ctx) ) {
			case 1:
				{
				this.state = 240;
				this.match(TodoLangGrammarParser.T__7);
				}
				break;
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public item(): ItemContext {
		let _localctx: ItemContext = new ItemContext(this._ctx, this.state);
		this.enterRule(_localctx, 32, TodoLangGrammarParser.RULE_item);
		let _la: number;
		try {
			this.state = 258;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 21, this._ctx) ) {
			case 1:
				_localctx = new SimpleJoinContext(_localctx);
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 243;
				this.unit();
				}
				break;

			case 2:
				_localctx = new SingleParenJoinContext(_localctx);
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 244;
				this.match(TodoLangGrammarParser.LeftP);
				this.state = 245;
				this.item();
				this.state = 246;
				this.match(TodoLangGrammarParser.RightP);
				}
				break;

			case 3:
				_localctx = new ParenJoinContext(_localctx);
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 248;
				this.match(TodoLangGrammarParser.LeftP);
				this.state = 249;
				this.item();
				this.state = 252;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				do {
					{
					{
					this.state = 250;
					this.match(TodoLangGrammarParser.OPER);
					this.state = 251;
					this.item();
					}
					}
					this.state = 254;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				} while (_la === TodoLangGrammarParser.OPER);
				this.state = 256;
				this.match(TodoLangGrammarParser.RightP);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public unit(): UnitContext {
		let _localctx: UnitContext = new UnitContext(this._ctx, this.state);
		this.enterRule(_localctx, 34, TodoLangGrammarParser.RULE_unit);
		try {
			this.state = 274;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 22, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 260;
				this.dataset();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 261;
				this.function();
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 262;
				this.set(0);
				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 263;
				this.cellPosition();
				}
				break;

			case 5:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 264;
				this.relativeCell();
				}
				break;

			case 6:
				this.enterOuterAlt(_localctx, 6);
				{
				this.state = 265;
				this.currentCellValue();
				}
				break;

			case 7:
				this.enterOuterAlt(_localctx, 7);
				{
				this.state = 266;
				this.currentCellData();
				}
				break;

			case 8:
				this.enterOuterAlt(_localctx, 8);
				{
				this.state = 267;
				this.cell();
				}
				break;

			case 9:
				this.enterOuterAlt(_localctx, 9);
				{
				this.state = 268;
				this.variable();
				}
				break;

			case 10:
				this.enterOuterAlt(_localctx, 10);
				{
				this.state = 269;
				this.match(TodoLangGrammarParser.INT);
				}
				break;

			case 11:
				this.enterOuterAlt(_localctx, 11);
				{
				this.state = 270;
				this.match(TodoLangGrammarParser.BOOLEAN);
				}
				break;

			case 12:
				this.enterOuterAlt(_localctx, 12);
				{
				this.state = 271;
				this.match(TodoLangGrammarParser.STRING);
				}
				break;

			case 13:
				this.enterOuterAlt(_localctx, 13);
				{
				this.state = 272;
				this.match(TodoLangGrammarParser.NUMBER);
				}
				break;

			case 14:
				this.enterOuterAlt(_localctx, 14);
				{
				this.state = 273;
				this.match(TodoLangGrammarParser.NULL);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public variable(): VariableContext {
		let _localctx: VariableContext = new VariableContext(this._ctx, this.state);
		this.enterRule(_localctx, 36, TodoLangGrammarParser.RULE_variable);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 276;
			this.match(TodoLangGrammarParser.IDEN);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public cellPosition(): CellPositionContext {
		let _localctx: CellPositionContext = new CellPositionContext(this._ctx, this.state);
		this.enterRule(_localctx, 38, TodoLangGrammarParser.RULE_cellPosition);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 278;
			this.match(TodoLangGrammarParser.T__10);
			this.state = 279;
			this.match(TodoLangGrammarParser.CELL);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public relativeCell(): RelativeCellContext {
		let _localctx: RelativeCellContext = new RelativeCellContext(this._ctx, this.state);
		this.enterRule(_localctx, 40, TodoLangGrammarParser.RULE_relativeCell);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 281;
			this.match(TodoLangGrammarParser.T__11);
			this.state = 282;
			this.match(TodoLangGrammarParser.CELL);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public currentCellValue(): CurrentCellValueContext {
		let _localctx: CurrentCellValueContext = new CurrentCellValueContext(this._ctx, this.state);
		this.enterRule(_localctx, 42, TodoLangGrammarParser.RULE_currentCellValue);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 284;
			this.match(TodoLangGrammarParser.T__12);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public currentCellData(): CurrentCellDataContext {
		let _localctx: CurrentCellDataContext = new CurrentCellDataContext(this._ctx, this.state);
		this.enterRule(_localctx, 44, TodoLangGrammarParser.RULE_currentCellData);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 286;
			this.match(TodoLangGrammarParser.T__12);
			this.state = 287;
			this.match(TodoLangGrammarParser.T__13);
			this.state = 288;
			this.property(0);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public cell(): CellContext {
		let _localctx: CellContext = new CellContext(this._ctx, this.state);
		this.enterRule(_localctx, 46, TodoLangGrammarParser.RULE_cell);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 290;
			this.match(TodoLangGrammarParser.T__14);
			this.state = 293;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 23, this._ctx) ) {
			case 1:
				{
				this.state = 291;
				this.match(TodoLangGrammarParser.T__13);
				this.state = 292;
				this.property(0);
				}
				break;
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public dataset(): DatasetContext {
		let _localctx: DatasetContext = new DatasetContext(this._ctx, this.state);
		this.enterRule(_localctx, 48, TodoLangGrammarParser.RULE_dataset);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 295;
			this.match(TodoLangGrammarParser.IDEN);
			this.state = 296;
			this.match(TodoLangGrammarParser.T__13);
			this.state = 297;
			this.aggregate();
			this.state = 298;
			this.match(TodoLangGrammarParser.LeftP);
			this.state = 300;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (((((_la - 30)) & ~0x1F) === 0 && ((1 << (_la - 30)) & ((1 << (TodoLangGrammarParser.COLUMN - 30)) | (1 << (TodoLangGrammarParser.INT - 30)) | (1 << (TodoLangGrammarParser.IDEN - 30)))) !== 0)) {
				{
				this.state = 299;
				this.datasetColumn();
				}
			}

			this.state = 304;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 25, this._ctx) ) {
			case 1:
				{
				this.state = 302;
				this.match(TodoLangGrammarParser.COMMA);
				this.state = 303;
				this.conditions();
				}
				break;
			}
			this.state = 308;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === TodoLangGrammarParser.COMMA) {
				{
				this.state = 306;
				this.match(TodoLangGrammarParser.COMMA);
				this.state = 307;
				this.match(TodoLangGrammarParser.ORDER);
				}
			}

			this.state = 310;
			this.match(TodoLangGrammarParser.RightP);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public datasetColumn(): DatasetColumnContext {
		let _localctx: DatasetColumnContext = new DatasetColumnContext(this._ctx, this.state);
		this.enterRule(_localctx, 50, TodoLangGrammarParser.RULE_datasetColumn);
		let _la: number;
		try {
			this.state = 326;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 28, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 312;
				this.property(0);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 313;
				this.match(TodoLangGrammarParser.IDEN);
				this.state = 314;
				this.match(TodoLangGrammarParser.LeftP);
				this.state = 315;
				this.property(0);
				this.state = 320;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === TodoLangGrammarParser.COMMA) {
					{
					{
					this.state = 316;
					this.match(TodoLangGrammarParser.COMMA);
					this.state = 317;
					this.expr();
					}
					}
					this.state = 322;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				this.state = 323;
				this.match(TodoLangGrammarParser.RightP);
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 325;
				this.match(TodoLangGrammarParser.INT);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public function(): FunctionContext {
		let _localctx: FunctionContext = new FunctionContext(this._ctx, this.state);
		this.enterRule(_localctx, 52, TodoLangGrammarParser.RULE_function);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 328;
			this.match(TodoLangGrammarParser.IDEN);
			this.state = 329;
			this.match(TodoLangGrammarParser.LeftP);
			this.state = 331;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (((((_la - 11)) & ~0x1F) === 0 && ((1 << (_la - 11)) & ((1 << (TodoLangGrammarParser.T__10 - 11)) | (1 << (TodoLangGrammarParser.T__11 - 11)) | (1 << (TodoLangGrammarParser.T__12 - 11)) | (1 << (TodoLangGrammarParser.T__14 - 11)) | (1 << (TodoLangGrammarParser.CELL - 11)) | (1 << (TodoLangGrammarParser.BOOLEAN - 11)) | (1 << (TodoLangGrammarParser.NULL - 11)) | (1 << (TodoLangGrammarParser.LeftP - 11)) | (1 << (TodoLangGrammarParser.STRING - 11)) | (1 << (TodoLangGrammarParser.INT - 11)) | (1 << (TodoLangGrammarParser.NUMBER - 11)) | (1 << (TodoLangGrammarParser.IDEN - 11)))) !== 0)) {
				{
				this.state = 330;
				this.functionParameter();
				}
			}

			this.state = 333;
			this.match(TodoLangGrammarParser.RightP);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public functionParameter(): FunctionParameterContext {
		let _localctx: FunctionParameterContext = new FunctionParameterContext(this._ctx, this.state);
		this.enterRule(_localctx, 54, TodoLangGrammarParser.RULE_functionParameter);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 335;
			this.expr();
			this.state = 340;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === TodoLangGrammarParser.COMMA) {
				{
				{
				this.state = 336;
				this.match(TodoLangGrammarParser.COMMA);
				this.state = 337;
				this.expr();
				}
				}
				this.state = 342;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}

	public set(): SetContext;
	public set(_p: number): SetContext;
	// @RuleVersion(0)
	public set(_p?: number): SetContext {
		if (_p === undefined) {
			_p = 0;
		}

		let _parentctx: ParserRuleContext = this._ctx;
		let _parentState: number = this.state;
		let _localctx: SetContext = new SetContext(this._ctx, _parentState);
		let _prevctx: SetContext = _localctx;
		let _startState: number = 56;
		this.enterRecursionRule(_localctx, 56, TodoLangGrammarParser.RULE_set, _p);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 376;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 32, this._ctx) ) {
			case 1:
				{
				_localctx = new SimpleDataContext(_localctx);
				this._ctx = _localctx;
				_prevctx = _localctx;

				this.state = 344;
				this.simpleValue();
				}
				break;

			case 2:
				{
				_localctx = new SingleCellContext(_localctx);
				this._ctx = _localctx;
				_prevctx = _localctx;
				this.state = 345;
				this.match(TodoLangGrammarParser.CELL);
				}
				break;

			case 3:
				{
				_localctx = new WholeCellContext(_localctx);
				this._ctx = _localctx;
				_prevctx = _localctx;
				this.state = 346;
				this.match(TodoLangGrammarParser.CELL);
				this.state = 347;
				this.match(TodoLangGrammarParser.T__15);
				this.state = 348;
				this.match(TodoLangGrammarParser.T__16);
				this.state = 353;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 31, this._ctx) ) {
				case 1:
					{
					this.state = 349;
					this.match(TodoLangGrammarParser.T__2);
					this.state = 350;
					this.conditions();
					this.state = 351;
					this.match(TodoLangGrammarParser.T__3);
					}
					break;
				}
				}
				break;

			case 4:
				{
				_localctx = new CellPairContext(_localctx);
				this._ctx = _localctx;
				_prevctx = _localctx;
				this.state = 355;
				this.match(TodoLangGrammarParser.CELL);
				this.state = 356;
				this.match(TodoLangGrammarParser.COLON);
				this.state = 357;
				this.match(TodoLangGrammarParser.CELL);
				}
				break;

			case 5:
				{
				_localctx = new SingleCellConditionContext(_localctx);
				this._ctx = _localctx;
				_prevctx = _localctx;
				this.state = 358;
				this.match(TodoLangGrammarParser.CELL);
				this.state = 359;
				this.match(TodoLangGrammarParser.T__2);
				this.state = 360;
				this.conditions();
				this.state = 361;
				this.match(TodoLangGrammarParser.T__3);
				}
				break;

			case 6:
				{
				_localctx = new SingleCellCoordinateContext(_localctx);
				this._ctx = _localctx;
				_prevctx = _localctx;
				this.state = 363;
				this.match(TodoLangGrammarParser.CELL);
				this.state = 364;
				this.match(TodoLangGrammarParser.T__15);
				this.state = 365;
				this.cellCoordinate();
				this.state = 366;
				this.match(TodoLangGrammarParser.T__16);
				}
				break;

			case 7:
				{
				_localctx = new CellCoordinateConditionContext(_localctx);
				this._ctx = _localctx;
				_prevctx = _localctx;
				this.state = 368;
				this.match(TodoLangGrammarParser.CELL);
				this.state = 369;
				this.match(TodoLangGrammarParser.T__15);
				this.state = 370;
				this.cellCoordinate();
				this.state = 371;
				this.match(TodoLangGrammarParser.T__16);
				this.state = 372;
				this.match(TodoLangGrammarParser.T__2);
				this.state = 373;
				this.conditions();
				this.state = 374;
				this.match(TodoLangGrammarParser.T__3);
				}
				break;
			}
			this._ctx._stop = this._input.tryLT(-1);
			this.state = 383;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 33, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					if (this._parseListeners != null) {
						this.triggerExitRuleEvent();
					}
					_prevctx = _localctx;
					{
					{
					_localctx = new RangeContext(new SetContext(_parentctx, _parentState));
					this.pushNewRecursionContext(_localctx, _startState, TodoLangGrammarParser.RULE_set);
					this.state = 378;
					if (!(this.precpred(this._ctx, 1))) {
						throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
					}
					this.state = 379;
					this.match(TodoLangGrammarParser.T__17);
					this.state = 380;
					this.set(2);
					}
					}
				}
				this.state = 385;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 33, this._ctx);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public cellCoordinate(): CellCoordinateContext {
		let _localctx: CellCoordinateContext = new CellCoordinateContext(this._ctx, this.state);
		this.enterRule(_localctx, 58, TodoLangGrammarParser.RULE_cellCoordinate);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 387;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === TodoLangGrammarParser.CELL) {
				{
				this.state = 386;
				this.coordinateLeft();
				}
			}

			this.state = 391;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === TodoLangGrammarParser.T__7) {
				{
				this.state = 389;
				this.match(TodoLangGrammarParser.T__7);
				this.state = 390;
				this.coordinateTop();
				}
			}

			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public coordinateLeft(): CoordinateLeftContext {
		let _localctx: CoordinateLeftContext = new CoordinateLeftContext(this._ctx, this.state);
		this.enterRule(_localctx, 60, TodoLangGrammarParser.RULE_coordinateLeft);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 393;
			this.coordinate();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public coordinateTop(): CoordinateTopContext {
		let _localctx: CoordinateTopContext = new CoordinateTopContext(this._ctx, this.state);
		this.enterRule(_localctx, 62, TodoLangGrammarParser.RULE_coordinateTop);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 395;
			this.coordinate();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public coordinate(): CoordinateContext {
		let _localctx: CoordinateContext = new CoordinateContext(this._ctx, this.state);
		this.enterRule(_localctx, 64, TodoLangGrammarParser.RULE_coordinate);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 397;
			this.cellIndicator();
			this.state = 402;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === TodoLangGrammarParser.COMMA) {
				{
				{
				this.state = 398;
				this.match(TodoLangGrammarParser.COMMA);
				this.state = 399;
				this.cellIndicator();
				}
				}
				this.state = 404;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public cellIndicator(): CellIndicatorContext {
		let _localctx: CellIndicatorContext = new CellIndicatorContext(this._ctx, this.state);
		this.enterRule(_localctx, 66, TodoLangGrammarParser.RULE_cellIndicator);
		let _la: number;
		try {
			this.state = 412;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 38, this._ctx) ) {
			case 1:
				_localctx = new RelativeContext(_localctx);
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 405;
				this.match(TodoLangGrammarParser.CELL);
				}
				break;

			case 2:
				_localctx = new AbsoluteContext(_localctx);
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 406;
				this.match(TodoLangGrammarParser.CELL);
				this.state = 407;
				this.match(TodoLangGrammarParser.COLON);
				this.state = 409;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === TodoLangGrammarParser.NOT) {
					{
					this.state = 408;
					this.match(TodoLangGrammarParser.NOT);
					}
				}

				this.state = 411;
				this.match(TodoLangGrammarParser.INT);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public conditions(): ConditionsContext {
		let _localctx: ConditionsContext = new ConditionsContext(this._ctx, this.state);
		this.enterRule(_localctx, 68, TodoLangGrammarParser.RULE_conditions);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 414;
			this.condition();
			this.state = 420;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === TodoLangGrammarParser.AND || _la === TodoLangGrammarParser.OR) {
				{
				{
				this.state = 415;
				this.join();
				this.state = 416;
				this.condition();
				}
				}
				this.state = 422;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public condition(): ConditionContext {
		let _localctx: ConditionContext = new ConditionContext(this._ctx, this.state);
		this.enterRule(_localctx, 70, TodoLangGrammarParser.RULE_condition);
		try {
			this.state = 438;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 40, this._ctx) ) {
			case 1:
				_localctx = new CellNameExprConditionContext(_localctx);
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 423;
				this.match(TodoLangGrammarParser.CELL);
				this.state = 424;
				this.match(TodoLangGrammarParser.OP);
				this.state = 425;
				this.expr();
				}
				break;

			case 2:
				_localctx = new PropertyConditionContext(_localctx);
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 426;
				this.property(0);
				this.state = 427;
				this.match(TodoLangGrammarParser.OP);
				this.state = 428;
				this.expr();
				}
				break;

			case 3:
				_localctx = new CurrentValueConditionContext(_localctx);
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 430;
				this.currentValue();
				this.state = 431;
				this.match(TodoLangGrammarParser.OP);
				this.state = 432;
				this.expr();
				}
				break;

			case 4:
				_localctx = new ExprConditionContext(_localctx);
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 434;
				this.expr();
				this.state = 435;
				this.match(TodoLangGrammarParser.OP);
				this.state = 436;
				this.expr();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}

	public property(): PropertyContext;
	public property(_p: number): PropertyContext;
	// @RuleVersion(0)
	public property(_p?: number): PropertyContext {
		if (_p === undefined) {
			_p = 0;
		}

		let _parentctx: ParserRuleContext = this._ctx;
		let _parentState: number = this.state;
		let _localctx: PropertyContext = new PropertyContext(this._ctx, _parentState);
		let _prevctx: PropertyContext = _localctx;
		let _startState: number = 72;
		this.enterRecursionRule(_localctx, 72, TodoLangGrammarParser.RULE_property, _p);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 443;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case TodoLangGrammarParser.IDEN:
				{
				this.state = 441;
				this.match(TodoLangGrammarParser.IDEN);
				}
				break;
			case TodoLangGrammarParser.COLUMN:
				{
				this.state = 442;
				this.match(TodoLangGrammarParser.COLUMN);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			this._ctx._stop = this._input.tryLT(-1);
			this.state = 450;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 42, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					if (this._parseListeners != null) {
						this.triggerExitRuleEvent();
					}
					_prevctx = _localctx;
					{
					{
					_localctx = new PropertyContext(_parentctx, _parentState);
					this.pushNewRecursionContext(_localctx, _startState, TodoLangGrammarParser.RULE_property);
					this.state = 445;
					if (!(this.precpred(this._ctx, 1))) {
						throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
					}
					this.state = 446;
					this.match(TodoLangGrammarParser.T__13);
					this.state = 447;
					this.property(2);
					}
					}
				}
				this.state = 452;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 42, this._ctx);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public currentValue(): CurrentValueContext {
		let _localctx: CurrentValueContext = new CurrentValueContext(this._ctx, this.state);
		this.enterRule(_localctx, 74, TodoLangGrammarParser.RULE_currentValue);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 453;
			this.match(TodoLangGrammarParser.T__18);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public simpleValue(): SimpleValueContext {
		let _localctx: SimpleValueContext = new SimpleValueContext(this._ctx, this.state);
		this.enterRule(_localctx, 76, TodoLangGrammarParser.RULE_simpleValue);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 455;
			_la = this._input.LA(1);
			if (!(((((_la - 24)) & ~0x1F) === 0 && ((1 << (_la - 24)) & ((1 << (TodoLangGrammarParser.BOOLEAN - 24)) | (1 << (TodoLangGrammarParser.NULL - 24)) | (1 << (TodoLangGrammarParser.STRING - 24)) | (1 << (TodoLangGrammarParser.INT - 24)) | (1 << (TodoLangGrammarParser.NUMBER - 24)))) !== 0))) {
			this._errHandler.recoverInline(this);
			} else {
				if (this._input.LA(1) === Token.EOF) {
					this.matchedEOF = true;
				}

				this._errHandler.reportMatch(this);
				this.consume();
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public join(): JoinContext {
		let _localctx: JoinContext = new JoinContext(this._ctx, this.state);
		this.enterRule(_localctx, 78, TodoLangGrammarParser.RULE_join);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 457;
			_la = this._input.LA(1);
			if (!(_la === TodoLangGrammarParser.AND || _la === TodoLangGrammarParser.OR)) {
			this._errHandler.recoverInline(this);
			} else {
				if (this._input.LA(1) === Token.EOF) {
					this.matchedEOF = true;
				}

				this._errHandler.reportMatch(this);
				this.consume();
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public aggregate(): AggregateContext {
		let _localctx: AggregateContext = new AggregateContext(this._ctx, this.state);
		this.enterRule(_localctx, 80, TodoLangGrammarParser.RULE_aggregate);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 459;
			this.match(TodoLangGrammarParser.IDEN);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}

	public sempred(_localctx: RuleContext, ruleIndex: number, predIndex: number): boolean {
		switch (ruleIndex) {
		case 2:
			return this.exprComposite_sempred(_localctx as ExprCompositeContext, predIndex);

		case 28:
			return this.set_sempred(_localctx as SetContext, predIndex);

		case 36:
			return this.property_sempred(_localctx as PropertyContext, predIndex);
		}
		return true;
	}
	private exprComposite_sempred(_localctx: ExprCompositeContext, predIndex: number): boolean {
		switch (predIndex) {
		case 0:
			return this.precpred(this._ctx, 1);
		}
		return true;
	}
	private set_sempred(_localctx: SetContext, predIndex: number): boolean {
		switch (predIndex) {
		case 1:
			return this.precpred(this._ctx, 1);
		}
		return true;
	}
	private property_sempred(_localctx: PropertyContext, predIndex: number): boolean {
		switch (predIndex) {
		case 2:
			return this.precpred(this._ctx, 1);
		}
		return true;
	}

	public static readonly _serializedATN: string =
		"\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03-\u01D0\x04\x02" +
		"\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04\x07" +
		"\t\x07\x04\b\t\b\x04\t\t\t\x04\n\t\n\x04\v\t\v\x04\f\t\f\x04\r\t\r\x04" +
		"\x0E\t\x0E\x04\x0F\t\x0F\x04\x10\t\x10\x04\x11\t\x11\x04\x12\t\x12\x04" +
		"\x13\t\x13\x04\x14\t\x14\x04\x15\t\x15\x04\x16\t\x16\x04\x17\t\x17\x04" +
		"\x18\t\x18\x04\x19\t\x19\x04\x1A\t\x1A\x04\x1B\t\x1B\x04\x1C\t\x1C\x04" +
		"\x1D\t\x1D\x04\x1E\t\x1E\x04\x1F\t\x1F\x04 \t \x04!\t!\x04\"\t\"\x04#" +
		"\t#\x04$\t$\x04%\t%\x04&\t&\x04\'\t\'\x04(\t(\x04)\t)\x04*\t*\x03\x02" +
		"\x06\x02V\n\x02\r\x02\x0E\x02W\x03\x02\x03\x02\x03\x03\x03\x03\x03\x03" +
		"\x03\x03\x03\x03\x05\x03a\n\x03\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
		"\x03\x04\x03\x04\x05\x04j\n\x04\x03\x04\x03\x04\x03\x04\x07\x04o\n\x04" +
		"\f\x04\x0E\x04r\v\x04\x03\x05\x03\x05\x03\x05\x03\x05\x07\x05x\n\x05\f" +
		"\x05\x0E\x05{\v\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x06\x03" +
		"\x06\x03\x06\x03\x06\x03\x06\x07\x06\x87\n\x06\f\x06\x0E\x06\x8A\v\x06" +
		"\x03\x06\x03\x06\x03\x07\x03\x07\x03\x07\x03\x07\x07\x07\x92\n\x07\f\x07" +
		"\x0E\x07\x95\v\x07\x03\x07\x05\x07\x98\n\x07\x03\x07\x03\x07\x03\b\x03" +
		"\b\x07\b\x9E\n\b\f\b\x0E\b\xA1\v\b\x03\b\x05\b\xA4\n\b\x03\t\x03\t\x03" +
		"\t\x03\t\x03\t\x03\t\x07\t\xAC\n\t\f\t\x0E\t\xAF\v\t\x03\t\x03\t\x03\t" +
		"\x03\t\x03\t\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x07\n\xBD\n\n\f" +
		"\n\x0E\n\xC0\v\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\v\x03\v\x03\v\x03\v" +
		"\x03\v\x03\f\x07\f\xCD\n\f\f\f\x0E\f\xD0\v\f\x03\f\x05\f\xD3\n\f\x03\r" +
		"\x03\r\x03\r\x05\r\xD8\n\r\x03\x0E\x05\x0E\xDB\n\x0E\x03\x0E\x03\x0E\x05" +
		"\x0E\xDF\n\x0E\x03\x0F\x03\x0F\x03\x0F\x07\x0F\xE4\n\x0F\f\x0F\x0E\x0F" +
		"\xE7\v\x0F\x03\x10\x03\x10\x03\x10\x03\x10\x03\x11\x05\x11\xEE\n\x11\x03" +
		"\x11\x03\x11\x03\x11\x03\x11\x05\x11\xF4\n\x11\x03\x12\x03\x12\x03\x12" +
		"\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x06\x12\xFF\n\x12\r\x12" +
		"\x0E\x12\u0100\x03\x12\x03\x12\x05\x12\u0105\n\x12\x03\x13\x03\x13\x03" +
		"\x13\x03\x13\x03\x13\x03\x13\x03\x13\x03\x13\x03\x13\x03\x13\x03\x13\x03" +
		"\x13\x03\x13\x03\x13\x05\x13\u0115\n\x13\x03\x14\x03\x14\x03\x15\x03\x15" +
		"\x03\x15\x03\x16\x03\x16\x03\x16\x03\x17\x03\x17\x03\x18\x03\x18\x03\x18" +
		"\x03\x18\x03\x19\x03\x19\x03\x19\x05\x19\u0128\n\x19\x03\x1A\x03\x1A\x03" +
		"\x1A\x03\x1A\x03\x1A\x05\x1A\u012F\n\x1A\x03\x1A\x03\x1A\x05\x1A\u0133" +
		"\n\x1A\x03\x1A\x03\x1A\x05\x1A\u0137\n\x1A\x03\x1A\x03\x1A\x03\x1B\x03" +
		"\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x07\x1B\u0141\n\x1B\f\x1B\x0E\x1B" +
		"\u0144\v\x1B\x03\x1B\x03\x1B\x03\x1B\x05\x1B\u0149\n\x1B\x03\x1C\x03\x1C" +
		"\x03\x1C\x05\x1C\u014E\n\x1C\x03\x1C\x03\x1C\x03\x1D\x03\x1D\x03\x1D\x07" +
		"\x1D\u0155\n\x1D\f\x1D\x0E\x1D\u0158\v\x1D\x03\x1E\x03\x1E\x03\x1E\x03" +
		"\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x05\x1E\u0164\n\x1E" +
		"\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E" +
		"\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E" +
		"\x03\x1E\x03\x1E\x03\x1E\x05\x1E\u017B\n\x1E\x03\x1E\x03\x1E\x03\x1E\x07" +
		"\x1E\u0180\n\x1E\f\x1E\x0E\x1E\u0183\v\x1E\x03\x1F\x05\x1F\u0186\n\x1F" +
		"\x03\x1F\x03\x1F\x05\x1F\u018A\n\x1F\x03 \x03 \x03!\x03!\x03\"\x03\"\x03" +
		"\"\x07\"\u0193\n\"\f\"\x0E\"\u0196\v\"\x03#\x03#\x03#\x03#\x05#\u019C" +
		"\n#\x03#\x05#\u019F\n#\x03$\x03$\x03$\x03$\x07$\u01A5\n$\f$\x0E$\u01A8" +
		"\v$\x03%\x03%\x03%\x03%\x03%\x03%\x03%\x03%\x03%\x03%\x03%\x03%\x03%\x03" +
		"%\x03%\x05%\u01B9\n%\x03&\x03&\x03&\x05&\u01BE\n&\x03&\x03&\x03&\x07&" +
		"\u01C3\n&\f&\x0E&\u01C6\v&\x03\'\x03\'\x03(\x03(\x03)\x03)\x03*\x03*\x03" +
		"*\x02\x02\x05\x06:J+\x02\x02\x04\x02\x06\x02\b\x02\n\x02\f\x02\x0E\x02" +
		"\x10\x02\x12\x02\x14\x02\x16\x02\x18\x02\x1A\x02\x1C\x02\x1E\x02 \x02" +
		"\"\x02$\x02&\x02(\x02*\x02,\x02.\x020\x022\x024\x026\x028\x02:\x02<\x02" +
		">\x02@\x02B\x02D\x02F\x02H\x02J\x02L\x02N\x02P\x02R\x02\x02\x04\x06\x02" +
		"\x1A\x1A\x1D\x1D!!$%\x03\x02\"#\x02\u01EB\x02U\x03\x02\x02\x02\x04`\x03" +
		"\x02\x02\x02\x06i\x03\x02\x02\x02\bs\x03\x02\x02\x02\n\x81\x03\x02\x02" +
		"\x02\f\x8D\x03\x02\x02\x02\x0E\x9B\x03\x02\x02\x02\x10\xA5\x03\x02\x02" +
		"\x02\x12\xB5\x03\x02\x02\x02\x14\xC6\x03\x02\x02\x02\x16\xCE\x03\x02\x02" +
		"\x02\x18\xD7\x03\x02\x02\x02\x1A\xDA\x03\x02\x02\x02\x1C\xE0\x03\x02\x02" +
		"\x02\x1E\xE8\x03\x02\x02\x02 \xED\x03\x02\x02\x02\"\u0104\x03\x02\x02" +
		"\x02$\u0114\x03\x02\x02\x02&\u0116\x03\x02\x02\x02(\u0118\x03\x02\x02" +
		"\x02*\u011B\x03\x02\x02\x02,\u011E\x03\x02\x02\x02.\u0120\x03\x02\x02" +
		"\x020\u0124\x03\x02\x02\x022\u0129\x03\x02\x02\x024\u0148\x03\x02\x02" +
		"\x026\u014A\x03\x02\x02\x028\u0151\x03\x02\x02\x02:\u017A\x03\x02\x02" +
		"\x02<\u0185\x03\x02\x02\x02>\u018B\x03\x02\x02\x02@\u018D\x03\x02\x02" +
		"\x02B\u018F\x03\x02\x02\x02D\u019E\x03\x02\x02\x02F\u01A0\x03\x02\x02" +
		"\x02H\u01B8\x03\x02\x02\x02J\u01BD\x03\x02\x02\x02L\u01C7\x03\x02\x02" +
		"\x02N\u01C9\x03\x02\x02\x02P\u01CB\x03\x02\x02\x02R\u01CD\x03\x02\x02" +
		"\x02TV\x05\x04\x03\x02UT\x03\x02\x02\x02VW\x03\x02\x02\x02WU\x03\x02\x02" +
		"\x02WX\x03\x02\x02\x02XY\x03\x02\x02\x02YZ\x07\x02\x02\x03Z\x03\x03\x02" +
		"\x02\x02[a\x05\x06\x04\x02\\a\x05\x0E\b\x02]a\x05\n\x06\x02^a\x05\x1A" +
		"\x0E\x02_a\x05 \x11\x02`[\x03\x02\x02\x02`\\\x03\x02\x02\x02`]\x03\x02" +
		"\x02\x02`^\x03\x02\x02\x02`_\x03\x02\x02\x02a\x05\x03\x02\x02\x02bc\b" +
		"\x04\x01\x02cj\x05\x1C\x0F\x02dj\x05\b\x05\x02ef\x07\x1E\x02\x02fg\x05" +
		"\x06\x04\x02gh\x07\x1F\x02\x02hj\x03\x02\x02\x02ib\x03\x02\x02\x02id\x03" +
		"\x02\x02\x02ie\x03\x02\x02\x02jp\x03\x02\x02\x02kl\f\x03\x02\x02lm\x07" +
		"\x16\x02\x02mo\x05\x06\x04\x04nk\x03\x02\x02\x02or\x03\x02\x02\x02pn\x03" +
		"\x02\x02\x02pq\x03\x02\x02\x02q\x07\x03\x02\x02\x02rp\x03\x02\x02\x02" +
		"sy\x05\x1E\x10\x02tu\x05P)\x02uv\x05\x1E\x10\x02vx\x03\x02\x02\x02wt\x03" +
		"\x02\x02\x02x{\x03\x02\x02\x02yw\x03\x02\x02\x02yz\x03\x02\x02\x02z|\x03" +
		"\x02\x02\x02{y\x03\x02\x02\x02|}\x07\x03\x02\x02}~\x05\x16\f\x02~\x7F" +
		"\x07\x1B\x02\x02\x7F\x80\x05\x16\f\x02\x80\t\x03\x02\x02\x02\x81\x82\x07" +
		"\x04\x02\x02\x82\x83\x07\x05\x02\x02\x83\x88\x05\f\x07\x02\x84\x85\x07" +
		"\x1C\x02\x02\x85\x87\x05\f\x07\x02\x86\x84\x03\x02\x02\x02\x87\x8A\x03" +
		"\x02\x02\x02\x88\x86\x03\x02\x02\x02\x88\x89\x03\x02\x02\x02\x89\x8B\x03" +
		"\x02\x02\x02\x8A\x88\x03\x02\x02\x02\x8B\x8C\x07\x06\x02\x02\x8C\v\x03" +
		"\x02\x02\x02\x8D\x93\x05\x1E\x10\x02\x8E\x8F\x05P)\x02\x8F\x90\x05\x1E" +
		"\x10\x02\x90\x92\x03\x02\x02\x02\x91\x8E\x03\x02\x02\x02\x92\x95\x03\x02" +
		"\x02\x02\x93\x91\x03\x02\x02\x02\x93\x94\x03\x02\x02\x02\x94\x97\x03\x02" +
		"\x02\x02\x95\x93\x03\x02\x02\x02\x96\x98\x07\x1B\x02\x02\x97\x96\x03\x02" +
		"\x02\x02\x97\x98\x03\x02\x02\x02\x98\x99\x03\x02\x02\x02\x99\x9A\x05\x16" +
		"\f\x02\x9A\r\x03\x02\x02\x02\x9B\x9F\x05\x10\t\x02\x9C\x9E\x05\x12\n\x02" +
		"\x9D\x9C\x03\x02\x02\x02\x9E\xA1\x03\x02\x02\x02\x9F\x9D\x03\x02\x02\x02" +
		"\x9F\xA0\x03\x02\x02\x02\xA0\xA3\x03\x02\x02\x02\xA1\x9F\x03\x02\x02\x02" +
		"\xA2\xA4\x05\x14\v\x02\xA3\xA2\x03\x02\x02\x02\xA3\xA4\x03\x02\x02\x02" +
		"\xA4\x0F\x03\x02\x02\x02\xA5\xA6\x07\x07\x02\x02\xA6\xA7\x07\x1E\x02\x02" +
		"\xA7\xAD\x05\x1E\x10\x02\xA8\xA9\x05P)\x02\xA9\xAA\x05\x1E\x10\x02\xAA" +
		"\xAC\x03\x02\x02\x02\xAB\xA8\x03\x02\x02\x02\xAC\xAF\x03\x02\x02\x02\xAD" +
		"\xAB\x03\x02\x02\x02\xAD\xAE\x03\x02\x02\x02\xAE\xB0\x03\x02\x02\x02\xAF" +
		"\xAD\x03\x02\x02\x02\xB0\xB1\x07\x1F\x02\x02\xB1\xB2\x07\x05\x02\x02\xB2" +
		"\xB3\x05\x16\f\x02\xB3\xB4\x07\x06\x02\x02\xB4\x11\x03\x02\x02\x02\xB5" +
		"\xB6\x07\b\x02\x02\xB6\xB7\x07\x07\x02\x02\xB7\xB8\x07\x1E\x02\x02\xB8" +
		"\xBE\x05\x1E\x10\x02\xB9\xBA\x05P)\x02\xBA\xBB\x05\x1E\x10\x02\xBB\xBD" +
		"\x03\x02\x02\x02\xBC\xB9\x03\x02\x02\x02\xBD\xC0\x03\x02\x02\x02\xBE\xBC" +
		"\x03\x02\x02\x02\xBE\xBF\x03\x02\x02\x02\xBF\xC1\x03\x02\x02\x02\xC0\xBE" +
		"\x03\x02\x02\x02\xC1\xC2\x07\x1F\x02\x02\xC2\xC3\x07\x05\x02\x02\xC3\xC4" +
		"\x05\x16\f\x02\xC4\xC5\x07\x06\x02\x02\xC5\x13\x03\x02\x02\x02\xC6\xC7" +
		"\x07\b\x02\x02\xC7\xC8\x07\x05\x02\x02\xC8\xC9\x05\x16\f\x02\xC9\xCA\x07" +
		"\x06\x02\x02\xCA\x15\x03\x02\x02\x02\xCB\xCD\x05\x18\r\x02\xCC\xCB\x03" +
		"\x02\x02\x02\xCD\xD0\x03\x02\x02\x02\xCE\xCC\x03\x02\x02\x02\xCE\xCF\x03" +
		"\x02\x02\x02\xCF\xD2\x03\x02\x02\x02\xD0\xCE\x03\x02\x02\x02\xD1\xD3\x05" +
		"\x1A\x0E\x02\xD2\xD1\x03\x02\x02\x02\xD2\xD3\x03\x02\x02\x02\xD3\x17\x03" +
		"\x02\x02\x02\xD4\xD8\x05 \x11\x02\xD5\xD8\x05\x0E\b\x02\xD6\xD8\x05\n" +
		"\x06\x02\xD7\xD4\x03\x02\x02\x02\xD7\xD5\x03\x02\x02\x02\xD7\xD6\x03\x02" +
		"\x02\x02\xD8\x19\x03\x02\x02\x02\xD9\xDB\x07\t\x02\x02\xDA\xD9\x03\x02" +
		"\x02\x02\xDA\xDB\x03\x02\x02\x02\xDB\xDC\x03\x02\x02\x02\xDC\xDE\x05\x1C" +
		"\x0F\x02\xDD\xDF\x07\n\x02\x02\xDE\xDD\x03\x02\x02\x02\xDE\xDF\x03\x02" +
		"\x02\x02\xDF\x1B\x03\x02\x02\x02\xE0\xE5\x05\"\x12\x02\xE1\xE2\x07\x16" +
		"\x02\x02\xE2\xE4\x05\"\x12\x02\xE3\xE1\x03\x02\x02\x02\xE4\xE7\x03\x02" +
		"\x02\x02\xE5\xE3\x03\x02\x02\x02\xE5\xE6\x03\x02\x02\x02\xE6\x1D\x03\x02" +
		"\x02\x02\xE7\xE5\x03\x02\x02\x02\xE8\xE9\x05\x1C\x0F\x02\xE9\xEA\x07\x17" +
		"\x02\x02\xEA\xEB\x05\x1C\x0F\x02\xEB\x1F\x03\x02\x02\x02\xEC\xEE\x07\v" +
		"\x02\x02\xED\xEC\x03\x02\x02\x02\xED\xEE\x03\x02\x02\x02\xEE\xEF\x03\x02" +
		"\x02\x02\xEF\xF0\x05&\x14\x02\xF0\xF1\x07\f\x02\x02\xF1\xF3\x05\x1C\x0F" +
		"\x02\xF2\xF4\x07\n\x02\x02\xF3\xF2\x03\x02\x02\x02\xF3\xF4\x03\x02\x02" +
		"\x02\xF4!\x03\x02\x02\x02\xF5\u0105\x05$\x13\x02\xF6\xF7\x07\x1E\x02\x02" +
		"\xF7\xF8\x05\"\x12\x02\xF8\xF9\x07\x1F\x02\x02\xF9\u0105\x03\x02\x02\x02" +
		"\xFA\xFB\x07\x1E\x02\x02\xFB\xFE\x05\"\x12\x02\xFC\xFD\x07\x16\x02\x02" +
		"\xFD\xFF\x05\"\x12\x02\xFE\xFC\x03\x02\x02\x02\xFF\u0100\x03\x02\x02\x02" +
		"\u0100\xFE\x03\x02\x02\x02\u0100\u0101\x03\x02\x02\x02\u0101\u0102\x03" +
		"\x02\x02\x02\u0102\u0103\x07\x1F\x02\x02\u0103\u0105\x03\x02\x02\x02\u0104" +
		"\xF5\x03\x02\x02\x02\u0104\xF6\x03\x02\x02\x02\u0104\xFA\x03\x02\x02\x02" +
		"\u0105#\x03\x02\x02\x02\u0106\u0115\x052\x1A\x02\u0107\u0115\x056\x1C" +
		"\x02\u0108\u0115\x05:\x1E\x02\u0109\u0115\x05(\x15\x02\u010A\u0115\x05" +
		"*\x16\x02\u010B\u0115\x05,\x17\x02\u010C\u0115\x05.\x18\x02\u010D\u0115" +
		"\x050\x19\x02\u010E\u0115\x05&\x14\x02\u010F\u0115\x07$\x02\x02\u0110" +
		"\u0115\x07\x1A\x02\x02\u0111\u0115\x07!\x02\x02\u0112\u0115\x07%\x02\x02" +
		"\u0113\u0115\x07\x1D\x02\x02\u0114\u0106\x03\x02\x02\x02\u0114\u0107\x03" +
		"\x02\x02\x02\u0114\u0108\x03\x02\x02\x02\u0114\u0109\x03\x02\x02\x02\u0114" +
		"\u010A\x03\x02\x02\x02\u0114\u010B\x03\x02\x02\x02\u0114\u010C\x03\x02" +
		"\x02\x02\u0114\u010D\x03\x02\x02\x02\u0114\u010E\x03\x02\x02\x02\u0114" +
		"\u010F\x03\x02\x02\x02\u0114\u0110\x03\x02\x02\x02\u0114\u0111\x03\x02" +
		"\x02\x02\u0114\u0112\x03\x02\x02\x02\u0114\u0113\x03\x02\x02\x02\u0115" +
		"%\x03\x02\x02\x02\u0116\u0117\x07\'\x02\x02\u0117\'\x03\x02\x02\x02\u0118" +
		"\u0119\x07\r\x02\x02\u0119\u011A\x07\x18\x02\x02\u011A)\x03\x02\x02\x02" +
		"\u011B\u011C\x07\x0E\x02\x02\u011C\u011D\x07\x18\x02\x02\u011D+\x03\x02" +
		"\x02\x02\u011E\u011F\x07\x0F\x02\x02\u011F-\x03\x02\x02\x02\u0120\u0121" +
		"\x07\x0F\x02\x02\u0121\u0122\x07\x10\x02\x02\u0122\u0123\x05J&\x02\u0123" +
		"/\x03\x02\x02\x02\u0124\u0127\x07\x11\x02\x02\u0125\u0126\x07\x10\x02" +
		"\x02\u0126\u0128\x05J&\x02\u0127\u0125\x03\x02\x02\x02\u0127\u0128\x03" +
		"\x02\x02\x02\u01281\x03\x02\x02\x02\u0129\u012A\x07\'\x02\x02\u012A\u012B" +
		"\x07\x10\x02\x02\u012B\u012C\x05R*\x02\u012C\u012E\x07\x1E\x02\x02\u012D" +
		"\u012F\x054\x1B\x02\u012E\u012D\x03\x02\x02\x02\u012E\u012F\x03\x02\x02" +
		"\x02\u012F\u0132\x03\x02\x02\x02\u0130\u0131\x07\x1C\x02\x02\u0131\u0133" +
		"\x05F$\x02\u0132\u0130\x03\x02\x02\x02\u0132\u0133\x03\x02\x02\x02\u0133" +
		"\u0136\x03\x02\x02\x02\u0134\u0135\x07\x1C\x02\x02\u0135\u0137\x07\x19" +
		"\x02\x02\u0136\u0134\x03\x02\x02\x02\u0136\u0137\x03\x02\x02\x02\u0137" +
		"\u0138\x03\x02\x02\x02\u0138\u0139\x07\x1F\x02\x02\u01393\x03\x02\x02" +
		"\x02\u013A\u0149\x05J&\x02\u013B\u013C\x07\'\x02\x02\u013C\u013D\x07\x1E" +
		"\x02\x02\u013D\u0142\x05J&\x02\u013E\u013F\x07\x1C\x02\x02\u013F\u0141" +
		"\x05\x1C\x0F\x02\u0140\u013E\x03\x02\x02\x02\u0141\u0144\x03\x02\x02\x02" +
		"\u0142\u0140\x03\x02\x02\x02\u0142\u0143\x03\x02\x02\x02\u0143\u0145\x03" +
		"\x02\x02\x02\u0144\u0142\x03\x02\x02\x02\u0145\u0146\x07\x1F\x02\x02\u0146" +
		"\u0149\x03\x02\x02\x02\u0147\u0149\x07$\x02\x02\u0148\u013A\x03\x02\x02" +
		"\x02\u0148\u013B\x03\x02\x02\x02\u0148\u0147\x03\x02\x02\x02\u01495\x03" +
		"\x02\x02\x02\u014A\u014B\x07\'\x02\x02\u014B\u014D\x07\x1E\x02\x02\u014C" +
		"\u014E\x058\x1D\x02\u014D\u014C\x03\x02\x02\x02\u014D\u014E\x03\x02\x02" +
		"\x02\u014E\u014F\x03\x02\x02\x02\u014F\u0150\x07\x1F\x02\x02\u01507\x03" +
		"\x02\x02\x02\u0151\u0156\x05\x1C\x0F\x02\u0152\u0153\x07\x1C\x02\x02\u0153" +
		"\u0155\x05\x1C\x0F\x02\u0154\u0152\x03\x02\x02\x02\u0155\u0158\x03\x02" +
		"\x02\x02\u0156\u0154\x03\x02\x02\x02\u0156\u0157\x03\x02\x02\x02\u0157" +
		"9\x03\x02\x02\x02\u0158\u0156\x03\x02\x02\x02\u0159\u015A\b\x1E\x01\x02" +
		"\u015A\u017B\x05N(\x02\u015B\u017B\x07\x18\x02\x02\u015C\u015D\x07\x18" +
		"\x02\x02\u015D\u015E\x07\x12\x02\x02\u015E\u0163\x07\x13\x02\x02\u015F" +
		"\u0160\x07\x05\x02\x02\u0160\u0161\x05F$\x02\u0161\u0162\x07\x06\x02\x02" +
		"\u0162\u0164\x03\x02\x02\x02\u0163\u015F\x03\x02\x02\x02\u0163\u0164\x03" +
		"\x02\x02\x02\u0164\u017B\x03\x02\x02\x02\u0165\u0166\x07\x18\x02\x02\u0166" +
		"\u0167\x07\x1B\x02\x02\u0167\u017B\x07\x18\x02\x02\u0168\u0169\x07\x18" +
		"\x02\x02\u0169\u016A\x07\x05\x02\x02\u016A\u016B\x05F$\x02\u016B\u016C" +
		"\x07\x06\x02\x02\u016C\u017B\x03\x02\x02\x02\u016D\u016E\x07\x18\x02\x02" +
		"\u016E\u016F\x07\x12\x02\x02\u016F\u0170\x05<\x1F\x02\u0170\u0171\x07" +
		"\x13\x02\x02\u0171\u017B\x03\x02\x02\x02\u0172\u0173\x07\x18\x02\x02\u0173" +
		"\u0174\x07\x12\x02\x02\u0174\u0175\x05<\x1F\x02\u0175\u0176\x07\x13\x02" +
		"\x02\u0176\u0177\x07\x05\x02\x02\u0177\u0178\x05F$\x02\u0178\u0179\x07" +
		"\x06\x02\x02\u0179\u017B\x03\x02\x02\x02\u017A\u0159\x03\x02\x02\x02\u017A" +
		"\u015B\x03\x02\x02\x02\u017A\u015C\x03\x02\x02\x02\u017A\u0165\x03\x02" +
		"\x02\x02\u017A\u0168\x03\x02\x02\x02\u017A\u016D\x03\x02\x02\x02\u017A" +
		"\u0172\x03\x02\x02\x02\u017B\u0181\x03\x02\x02\x02\u017C\u017D\f\x03\x02" +
		"\x02\u017D\u017E\x07\x14\x02\x02\u017E\u0180\x05:\x1E\x04\u017F\u017C" +
		"\x03\x02\x02\x02\u0180\u0183\x03\x02\x02\x02\u0181\u017F\x03\x02\x02\x02" +
		"\u0181\u0182\x03\x02\x02\x02\u0182;\x03\x02\x02\x02\u0183\u0181\x03\x02" +
		"\x02\x02\u0184\u0186\x05> \x02\u0185\u0184\x03\x02\x02\x02\u0185\u0186" +
		"\x03\x02\x02\x02\u0186\u0189\x03\x02\x02\x02\u0187\u0188\x07\n\x02\x02" +
		"\u0188\u018A\x05@!\x02\u0189\u0187\x03\x02\x02\x02\u0189\u018A\x03\x02" +
		"\x02\x02\u018A=\x03\x02\x02\x02\u018B\u018C\x05B\"\x02\u018C?\x03\x02" +
		"\x02\x02\u018D\u018E\x05B\"\x02\u018EA\x03\x02\x02\x02\u018F\u0194\x05" +
		"D#\x02\u0190\u0191\x07\x1C\x02\x02\u0191\u0193\x05D#\x02\u0192\u0190\x03" +
		"\x02\x02\x02\u0193\u0196\x03\x02\x02\x02\u0194\u0192\x03\x02\x02\x02\u0194" +
		"\u0195\x03\x02\x02\x02\u0195C\x03\x02\x02\x02\u0196\u0194\x03\x02\x02" +
		"\x02\u0197\u019F\x07\x18\x02\x02\u0198\u0199\x07\x18\x02\x02\u0199\u019B" +
		"\x07\x1B\x02\x02\u019A\u019C\x07&\x02\x02\u019B\u019A\x03\x02\x02\x02" +
		"\u019B\u019C\x03\x02\x02\x02\u019C\u019D\x03\x02\x02\x02\u019D\u019F\x07" +
		"$\x02\x02\u019E\u0197\x03\x02\x02\x02\u019E\u0198\x03\x02\x02\x02\u019F" +
		"E\x03\x02\x02\x02\u01A0\u01A6\x05H%\x02\u01A1\u01A2\x05P)\x02\u01A2\u01A3" +
		"\x05H%\x02\u01A3\u01A5\x03\x02\x02\x02\u01A4\u01A1\x03\x02\x02\x02\u01A5" +
		"\u01A8\x03\x02\x02\x02\u01A6\u01A4\x03\x02\x02\x02\u01A6\u01A7\x03\x02" +
		"\x02\x02\u01A7G\x03\x02\x02\x02\u01A8\u01A6\x03\x02\x02\x02\u01A9\u01AA" +
		"\x07\x18\x02\x02\u01AA\u01AB\x07\x17\x02\x02\u01AB\u01B9\x05\x1C\x0F\x02" +
		"\u01AC\u01AD\x05J&\x02\u01AD\u01AE\x07\x17\x02\x02\u01AE\u01AF\x05\x1C" +
		"\x0F\x02\u01AF\u01B9\x03\x02\x02\x02\u01B0\u01B1\x05L\'\x02\u01B1\u01B2" +
		"\x07\x17\x02\x02\u01B2\u01B3\x05\x1C\x0F\x02\u01B3\u01B9\x03\x02\x02\x02" +
		"\u01B4\u01B5\x05\x1C\x0F\x02\u01B5\u01B6\x07\x17\x02\x02\u01B6\u01B7\x05" +
		"\x1C\x0F\x02\u01B7\u01B9\x03\x02\x02\x02\u01B8\u01A9\x03\x02\x02\x02\u01B8" +
		"\u01AC\x03\x02\x02\x02\u01B8\u01B0\x03\x02\x02\x02\u01B8\u01B4\x03\x02" +
		"\x02\x02\u01B9I\x03\x02\x02\x02\u01BA\u01BB\b&\x01\x02\u01BB\u01BE\x07" +
		"\'\x02\x02\u01BC\u01BE\x07 \x02\x02\u01BD\u01BA\x03\x02\x02\x02\u01BD" +
		"\u01BC\x03\x02\x02\x02\u01BE\u01C4\x03\x02\x02\x02\u01BF\u01C0\f\x03\x02" +
		"\x02\u01C0\u01C1\x07\x10\x02\x02\u01C1\u01C3\x05J&\x04\u01C2\u01BF\x03" +
		"\x02\x02\x02\u01C3\u01C6\x03\x02\x02\x02\u01C4\u01C2\x03\x02\x02\x02\u01C4" +
		"\u01C5\x03\x02\x02\x02\u01C5K\x03\x02\x02\x02\u01C6\u01C4\x03\x02\x02" +
		"\x02\u01C7\u01C8\x07\x15\x02\x02\u01C8M\x03\x02\x02\x02\u01C9\u01CA\t" +
		"\x02\x02\x02\u01CAO\x03\x02\x02\x02\u01CB\u01CC\t\x03\x02\x02\u01CCQ\x03" +
		"\x02\x02\x02\u01CD\u01CE\x07\'\x02\x02\u01CES\x03\x02\x02\x02-W`ipy\x88" +
		"\x93\x97\x9F\xA3\xAD\xBE\xCE\xD2\xD7\xDA\xDE\xE5\xED\xF3\u0100\u0104\u0114" +
		"\u0127\u012E\u0132\u0136\u0142\u0148\u014D\u0156\u0163\u017A\u0181\u0185" +
		"\u0189\u0194\u019B\u019E\u01A6\u01B8\u01BD\u01C4";
	public static __ATN: ATN;
	public static get _ATN(): ATN {
		if (!TodoLangGrammarParser.__ATN) {
			TodoLangGrammarParser.__ATN = new ATNDeserializer().deserialize(Utils.toCharArray(TodoLangGrammarParser._serializedATN));
		}

		return TodoLangGrammarParser.__ATN;
	}

}

export class EntryContext extends ParserRuleContext {
	public EOF(): TerminalNode { return this.getToken(TodoLangGrammarParser.EOF, 0); }
	public expression(): ExpressionContext[];
	public expression(i: number): ExpressionContext;
	public expression(i?: number): ExpressionContext | ExpressionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExpressionContext);
		} else {
			return this.getRuleContext(i, ExpressionContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_entry; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterEntry) {
			listener.enterEntry(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitEntry) {
			listener.exitEntry(this);
		}
	}
}


export class ExpressionContext extends ParserRuleContext {
	public exprComposite(): ExprCompositeContext | undefined {
		return this.tryGetRuleContext(0, ExprCompositeContext);
	}
	public ifExpr(): IfExprContext | undefined {
		return this.tryGetRuleContext(0, IfExprContext);
	}
	public caseExpr(): CaseExprContext | undefined {
		return this.tryGetRuleContext(0, CaseExprContext);
	}
	public returnExpr(): ReturnExprContext | undefined {
		return this.tryGetRuleContext(0, ReturnExprContext);
	}
	public variableAssign(): VariableAssignContext | undefined {
		return this.tryGetRuleContext(0, VariableAssignContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_expression; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterExpression) {
			listener.enterExpression(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitExpression) {
			listener.exitExpression(this);
		}
	}
}


export class ExprCompositeContext extends ParserRuleContext {
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_exprComposite; }
	public copyFrom(ctx: ExprCompositeContext): void {
		super.copyFrom(ctx);
	}
}
export class SingleExprCompositeContext extends ExprCompositeContext {
	public expr(): ExprContext {
		return this.getRuleContext(0, ExprContext);
	}
	constructor(ctx: ExprCompositeContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterSingleExprComposite) {
			listener.enterSingleExprComposite(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitSingleExprComposite) {
			listener.exitSingleExprComposite(this);
		}
	}
}
export class TernaryExprCompositeContext extends ExprCompositeContext {
	public ternaryExpr(): TernaryExprContext {
		return this.getRuleContext(0, TernaryExprContext);
	}
	constructor(ctx: ExprCompositeContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterTernaryExprComposite) {
			listener.enterTernaryExprComposite(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitTernaryExprComposite) {
			listener.exitTernaryExprComposite(this);
		}
	}
}
export class ParenExprCompositeContext extends ExprCompositeContext {
	public LeftP(): TerminalNode { return this.getToken(TodoLangGrammarParser.LeftP, 0); }
	public exprComposite(): ExprCompositeContext {
		return this.getRuleContext(0, ExprCompositeContext);
	}
	public RightP(): TerminalNode { return this.getToken(TodoLangGrammarParser.RightP, 0); }
	constructor(ctx: ExprCompositeContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterParenExprComposite) {
			listener.enterParenExprComposite(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitParenExprComposite) {
			listener.exitParenExprComposite(this);
		}
	}
}
export class ComplexExprCompositeContext extends ExprCompositeContext {
	public exprComposite(): ExprCompositeContext[];
	public exprComposite(i: number): ExprCompositeContext;
	public exprComposite(i?: number): ExprCompositeContext | ExprCompositeContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExprCompositeContext);
		} else {
			return this.getRuleContext(i, ExprCompositeContext);
		}
	}
	public OPER(): TerminalNode { return this.getToken(TodoLangGrammarParser.OPER, 0); }
	constructor(ctx: ExprCompositeContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterComplexExprComposite) {
			listener.enterComplexExprComposite(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitComplexExprComposite) {
			listener.exitComplexExprComposite(this);
		}
	}
}


export class TernaryExprContext extends ParserRuleContext {
	public ifCondition(): IfConditionContext[];
	public ifCondition(i: number): IfConditionContext;
	public ifCondition(i?: number): IfConditionContext | IfConditionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(IfConditionContext);
		} else {
			return this.getRuleContext(i, IfConditionContext);
		}
	}
	public block(): BlockContext[];
	public block(i: number): BlockContext;
	public block(i?: number): BlockContext | BlockContext[] {
		if (i === undefined) {
			return this.getRuleContexts(BlockContext);
		} else {
			return this.getRuleContext(i, BlockContext);
		}
	}
	public COLON(): TerminalNode { return this.getToken(TodoLangGrammarParser.COLON, 0); }
	public join(): JoinContext[];
	public join(i: number): JoinContext;
	public join(i?: number): JoinContext | JoinContext[] {
		if (i === undefined) {
			return this.getRuleContexts(JoinContext);
		} else {
			return this.getRuleContext(i, JoinContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_ternaryExpr; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterTernaryExpr) {
			listener.enterTernaryExpr(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitTernaryExpr) {
			listener.exitTernaryExpr(this);
		}
	}
}


export class CaseExprContext extends ParserRuleContext {
	public casePart(): CasePartContext[];
	public casePart(i: number): CasePartContext;
	public casePart(i?: number): CasePartContext | CasePartContext[] {
		if (i === undefined) {
			return this.getRuleContexts(CasePartContext);
		} else {
			return this.getRuleContext(i, CasePartContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(TodoLangGrammarParser.COMMA);
		} else {
			return this.getToken(TodoLangGrammarParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_caseExpr; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterCaseExpr) {
			listener.enterCaseExpr(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitCaseExpr) {
			listener.exitCaseExpr(this);
		}
	}
}


export class CasePartContext extends ParserRuleContext {
	public ifCondition(): IfConditionContext[];
	public ifCondition(i: number): IfConditionContext;
	public ifCondition(i?: number): IfConditionContext | IfConditionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(IfConditionContext);
		} else {
			return this.getRuleContext(i, IfConditionContext);
		}
	}
	public block(): BlockContext {
		return this.getRuleContext(0, BlockContext);
	}
	public join(): JoinContext[];
	public join(i: number): JoinContext;
	public join(i?: number): JoinContext | JoinContext[] {
		if (i === undefined) {
			return this.getRuleContexts(JoinContext);
		} else {
			return this.getRuleContext(i, JoinContext);
		}
	}
	public COLON(): TerminalNode | undefined { return this.tryGetToken(TodoLangGrammarParser.COLON, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_casePart; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterCasePart) {
			listener.enterCasePart(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitCasePart) {
			listener.exitCasePart(this);
		}
	}
}


export class IfExprContext extends ParserRuleContext {
	public ifPart(): IfPartContext {
		return this.getRuleContext(0, IfPartContext);
	}
	public elseIfPart(): ElseIfPartContext[];
	public elseIfPart(i: number): ElseIfPartContext;
	public elseIfPart(i?: number): ElseIfPartContext | ElseIfPartContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ElseIfPartContext);
		} else {
			return this.getRuleContext(i, ElseIfPartContext);
		}
	}
	public elsePart(): ElsePartContext | undefined {
		return this.tryGetRuleContext(0, ElsePartContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_ifExpr; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterIfExpr) {
			listener.enterIfExpr(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitIfExpr) {
			listener.exitIfExpr(this);
		}
	}
}


export class IfPartContext extends ParserRuleContext {
	public LeftP(): TerminalNode { return this.getToken(TodoLangGrammarParser.LeftP, 0); }
	public ifCondition(): IfConditionContext[];
	public ifCondition(i: number): IfConditionContext;
	public ifCondition(i?: number): IfConditionContext | IfConditionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(IfConditionContext);
		} else {
			return this.getRuleContext(i, IfConditionContext);
		}
	}
	public RightP(): TerminalNode { return this.getToken(TodoLangGrammarParser.RightP, 0); }
	public block(): BlockContext {
		return this.getRuleContext(0, BlockContext);
	}
	public join(): JoinContext[];
	public join(i: number): JoinContext;
	public join(i?: number): JoinContext | JoinContext[] {
		if (i === undefined) {
			return this.getRuleContexts(JoinContext);
		} else {
			return this.getRuleContext(i, JoinContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_ifPart; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterIfPart) {
			listener.enterIfPart(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitIfPart) {
			listener.exitIfPart(this);
		}
	}
}


export class ElseIfPartContext extends ParserRuleContext {
	public LeftP(): TerminalNode { return this.getToken(TodoLangGrammarParser.LeftP, 0); }
	public ifCondition(): IfConditionContext[];
	public ifCondition(i: number): IfConditionContext;
	public ifCondition(i?: number): IfConditionContext | IfConditionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(IfConditionContext);
		} else {
			return this.getRuleContext(i, IfConditionContext);
		}
	}
	public RightP(): TerminalNode { return this.getToken(TodoLangGrammarParser.RightP, 0); }
	public block(): BlockContext {
		return this.getRuleContext(0, BlockContext);
	}
	public join(): JoinContext[];
	public join(i: number): JoinContext;
	public join(i?: number): JoinContext | JoinContext[] {
		if (i === undefined) {
			return this.getRuleContexts(JoinContext);
		} else {
			return this.getRuleContext(i, JoinContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_elseIfPart; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterElseIfPart) {
			listener.enterElseIfPart(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitElseIfPart) {
			listener.exitElseIfPart(this);
		}
	}
}


export class ElsePartContext extends ParserRuleContext {
	public block(): BlockContext {
		return this.getRuleContext(0, BlockContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_elsePart; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterElsePart) {
			listener.enterElsePart(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitElsePart) {
			listener.exitElsePart(this);
		}
	}
}


export class BlockContext extends ParserRuleContext {
	public exprBlock(): ExprBlockContext[];
	public exprBlock(i: number): ExprBlockContext;
	public exprBlock(i?: number): ExprBlockContext | ExprBlockContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExprBlockContext);
		} else {
			return this.getRuleContext(i, ExprBlockContext);
		}
	}
	public returnExpr(): ReturnExprContext | undefined {
		return this.tryGetRuleContext(0, ReturnExprContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_block; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterBlock) {
			listener.enterBlock(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitBlock) {
			listener.exitBlock(this);
		}
	}
}


export class ExprBlockContext extends ParserRuleContext {
	public variableAssign(): VariableAssignContext | undefined {
		return this.tryGetRuleContext(0, VariableAssignContext);
	}
	public ifExpr(): IfExprContext | undefined {
		return this.tryGetRuleContext(0, IfExprContext);
	}
	public caseExpr(): CaseExprContext | undefined {
		return this.tryGetRuleContext(0, CaseExprContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_exprBlock; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterExprBlock) {
			listener.enterExprBlock(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitExprBlock) {
			listener.exitExprBlock(this);
		}
	}
}


export class ReturnExprContext extends ParserRuleContext {
	public expr(): ExprContext {
		return this.getRuleContext(0, ExprContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_returnExpr; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterReturnExpr) {
			listener.enterReturnExpr(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitReturnExpr) {
			listener.exitReturnExpr(this);
		}
	}
}


export class ExprContext extends ParserRuleContext {
	public item(): ItemContext[];
	public item(i: number): ItemContext;
	public item(i?: number): ItemContext | ItemContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ItemContext);
		} else {
			return this.getRuleContext(i, ItemContext);
		}
	}
	public OPER(): TerminalNode[];
	public OPER(i: number): TerminalNode;
	public OPER(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(TodoLangGrammarParser.OPER);
		} else {
			return this.getToken(TodoLangGrammarParser.OPER, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_expr; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterExpr) {
			listener.enterExpr(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitExpr) {
			listener.exitExpr(this);
		}
	}
}


export class IfConditionContext extends ParserRuleContext {
	public expr(): ExprContext[];
	public expr(i: number): ExprContext;
	public expr(i?: number): ExprContext | ExprContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExprContext);
		} else {
			return this.getRuleContext(i, ExprContext);
		}
	}
	public OP(): TerminalNode { return this.getToken(TodoLangGrammarParser.OP, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_ifCondition; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterIfCondition) {
			listener.enterIfCondition(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitIfCondition) {
			listener.exitIfCondition(this);
		}
	}
}


export class VariableAssignContext extends ParserRuleContext {
	public variable(): VariableContext {
		return this.getRuleContext(0, VariableContext);
	}
	public expr(): ExprContext {
		return this.getRuleContext(0, ExprContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_variableAssign; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterVariableAssign) {
			listener.enterVariableAssign(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitVariableAssign) {
			listener.exitVariableAssign(this);
		}
	}
}


export class ItemContext extends ParserRuleContext {
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_item; }
	public copyFrom(ctx: ItemContext): void {
		super.copyFrom(ctx);
	}
}
export class SimpleJoinContext extends ItemContext {
	public unit(): UnitContext {
		return this.getRuleContext(0, UnitContext);
	}
	constructor(ctx: ItemContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterSimpleJoin) {
			listener.enterSimpleJoin(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitSimpleJoin) {
			listener.exitSimpleJoin(this);
		}
	}
}
export class SingleParenJoinContext extends ItemContext {
	public LeftP(): TerminalNode { return this.getToken(TodoLangGrammarParser.LeftP, 0); }
	public item(): ItemContext {
		return this.getRuleContext(0, ItemContext);
	}
	public RightP(): TerminalNode { return this.getToken(TodoLangGrammarParser.RightP, 0); }
	constructor(ctx: ItemContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterSingleParenJoin) {
			listener.enterSingleParenJoin(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitSingleParenJoin) {
			listener.exitSingleParenJoin(this);
		}
	}
}
export class ParenJoinContext extends ItemContext {
	public LeftP(): TerminalNode { return this.getToken(TodoLangGrammarParser.LeftP, 0); }
	public item(): ItemContext[];
	public item(i: number): ItemContext;
	public item(i?: number): ItemContext | ItemContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ItemContext);
		} else {
			return this.getRuleContext(i, ItemContext);
		}
	}
	public RightP(): TerminalNode { return this.getToken(TodoLangGrammarParser.RightP, 0); }
	public OPER(): TerminalNode[];
	public OPER(i: number): TerminalNode;
	public OPER(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(TodoLangGrammarParser.OPER);
		} else {
			return this.getToken(TodoLangGrammarParser.OPER, i);
		}
	}
	constructor(ctx: ItemContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterParenJoin) {
			listener.enterParenJoin(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitParenJoin) {
			listener.exitParenJoin(this);
		}
	}
}


export class UnitContext extends ParserRuleContext {
	public dataset(): DatasetContext | undefined {
		return this.tryGetRuleContext(0, DatasetContext);
	}
	public function(): FunctionContext | undefined {
		return this.tryGetRuleContext(0, FunctionContext);
	}
	public set(): SetContext | undefined {
		return this.tryGetRuleContext(0, SetContext);
	}
	public cellPosition(): CellPositionContext | undefined {
		return this.tryGetRuleContext(0, CellPositionContext);
	}
	public relativeCell(): RelativeCellContext | undefined {
		return this.tryGetRuleContext(0, RelativeCellContext);
	}
	public currentCellValue(): CurrentCellValueContext | undefined {
		return this.tryGetRuleContext(0, CurrentCellValueContext);
	}
	public currentCellData(): CurrentCellDataContext | undefined {
		return this.tryGetRuleContext(0, CurrentCellDataContext);
	}
	public cell(): CellContext | undefined {
		return this.tryGetRuleContext(0, CellContext);
	}
	public variable(): VariableContext | undefined {
		return this.tryGetRuleContext(0, VariableContext);
	}
	public INT(): TerminalNode | undefined { return this.tryGetToken(TodoLangGrammarParser.INT, 0); }
	public BOOLEAN(): TerminalNode | undefined { return this.tryGetToken(TodoLangGrammarParser.BOOLEAN, 0); }
	public STRING(): TerminalNode | undefined { return this.tryGetToken(TodoLangGrammarParser.STRING, 0); }
	public NUMBER(): TerminalNode | undefined { return this.tryGetToken(TodoLangGrammarParser.NUMBER, 0); }
	public NULL(): TerminalNode | undefined { return this.tryGetToken(TodoLangGrammarParser.NULL, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_unit; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterUnit) {
			listener.enterUnit(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitUnit) {
			listener.exitUnit(this);
		}
	}
}


export class VariableContext extends ParserRuleContext {
	public IDEN(): TerminalNode { return this.getToken(TodoLangGrammarParser.IDEN, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_variable; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterVariable) {
			listener.enterVariable(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitVariable) {
			listener.exitVariable(this);
		}
	}
}


export class CellPositionContext extends ParserRuleContext {
	public CELL(): TerminalNode { return this.getToken(TodoLangGrammarParser.CELL, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_cellPosition; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterCellPosition) {
			listener.enterCellPosition(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitCellPosition) {
			listener.exitCellPosition(this);
		}
	}
}


export class RelativeCellContext extends ParserRuleContext {
	public CELL(): TerminalNode { return this.getToken(TodoLangGrammarParser.CELL, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_relativeCell; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterRelativeCell) {
			listener.enterRelativeCell(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitRelativeCell) {
			listener.exitRelativeCell(this);
		}
	}
}


export class CurrentCellValueContext extends ParserRuleContext {
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_currentCellValue; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterCurrentCellValue) {
			listener.enterCurrentCellValue(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitCurrentCellValue) {
			listener.exitCurrentCellValue(this);
		}
	}
}


export class CurrentCellDataContext extends ParserRuleContext {
	public property(): PropertyContext {
		return this.getRuleContext(0, PropertyContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_currentCellData; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterCurrentCellData) {
			listener.enterCurrentCellData(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitCurrentCellData) {
			listener.exitCurrentCellData(this);
		}
	}
}


export class CellContext extends ParserRuleContext {
	public property(): PropertyContext | undefined {
		return this.tryGetRuleContext(0, PropertyContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_cell; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterCell) {
			listener.enterCell(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitCell) {
			listener.exitCell(this);
		}
	}
}


export class DatasetContext extends ParserRuleContext {
	public IDEN(): TerminalNode { return this.getToken(TodoLangGrammarParser.IDEN, 0); }
	public aggregate(): AggregateContext {
		return this.getRuleContext(0, AggregateContext);
	}
	public LeftP(): TerminalNode { return this.getToken(TodoLangGrammarParser.LeftP, 0); }
	public RightP(): TerminalNode { return this.getToken(TodoLangGrammarParser.RightP, 0); }
	public datasetColumn(): DatasetColumnContext | undefined {
		return this.tryGetRuleContext(0, DatasetColumnContext);
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(TodoLangGrammarParser.COMMA);
		} else {
			return this.getToken(TodoLangGrammarParser.COMMA, i);
		}
	}
	public conditions(): ConditionsContext | undefined {
		return this.tryGetRuleContext(0, ConditionsContext);
	}
	public ORDER(): TerminalNode | undefined { return this.tryGetToken(TodoLangGrammarParser.ORDER, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_dataset; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterDataset) {
			listener.enterDataset(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitDataset) {
			listener.exitDataset(this);
		}
	}
}


export class DatasetColumnContext extends ParserRuleContext {
	public property(): PropertyContext | undefined {
		return this.tryGetRuleContext(0, PropertyContext);
	}
	public IDEN(): TerminalNode | undefined { return this.tryGetToken(TodoLangGrammarParser.IDEN, 0); }
	public LeftP(): TerminalNode | undefined { return this.tryGetToken(TodoLangGrammarParser.LeftP, 0); }
	public RightP(): TerminalNode | undefined { return this.tryGetToken(TodoLangGrammarParser.RightP, 0); }
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(TodoLangGrammarParser.COMMA);
		} else {
			return this.getToken(TodoLangGrammarParser.COMMA, i);
		}
	}
	public expr(): ExprContext[];
	public expr(i: number): ExprContext;
	public expr(i?: number): ExprContext | ExprContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExprContext);
		} else {
			return this.getRuleContext(i, ExprContext);
		}
	}
	public INT(): TerminalNode | undefined { return this.tryGetToken(TodoLangGrammarParser.INT, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_datasetColumn; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterDatasetColumn) {
			listener.enterDatasetColumn(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitDatasetColumn) {
			listener.exitDatasetColumn(this);
		}
	}
}


export class FunctionContext extends ParserRuleContext {
	public IDEN(): TerminalNode { return this.getToken(TodoLangGrammarParser.IDEN, 0); }
	public LeftP(): TerminalNode { return this.getToken(TodoLangGrammarParser.LeftP, 0); }
	public RightP(): TerminalNode { return this.getToken(TodoLangGrammarParser.RightP, 0); }
	public functionParameter(): FunctionParameterContext | undefined {
		return this.tryGetRuleContext(0, FunctionParameterContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_function; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterFunction) {
			listener.enterFunction(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitFunction) {
			listener.exitFunction(this);
		}
	}
}


export class FunctionParameterContext extends ParserRuleContext {
	public expr(): ExprContext[];
	public expr(i: number): ExprContext;
	public expr(i?: number): ExprContext | ExprContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExprContext);
		} else {
			return this.getRuleContext(i, ExprContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(TodoLangGrammarParser.COMMA);
		} else {
			return this.getToken(TodoLangGrammarParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_functionParameter; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterFunctionParameter) {
			listener.enterFunctionParameter(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitFunctionParameter) {
			listener.exitFunctionParameter(this);
		}
	}
}


export class SetContext extends ParserRuleContext {
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_set; }
	public copyFrom(ctx: SetContext): void {
		super.copyFrom(ctx);
	}
}
export class SimpleDataContext extends SetContext {
	public simpleValue(): SimpleValueContext {
		return this.getRuleContext(0, SimpleValueContext);
	}
	constructor(ctx: SetContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterSimpleData) {
			listener.enterSimpleData(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitSimpleData) {
			listener.exitSimpleData(this);
		}
	}
}
export class SingleCellContext extends SetContext {
	public CELL(): TerminalNode { return this.getToken(TodoLangGrammarParser.CELL, 0); }
	constructor(ctx: SetContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterSingleCell) {
			listener.enterSingleCell(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitSingleCell) {
			listener.exitSingleCell(this);
		}
	}
}
export class WholeCellContext extends SetContext {
	public CELL(): TerminalNode { return this.getToken(TodoLangGrammarParser.CELL, 0); }
	public conditions(): ConditionsContext | undefined {
		return this.tryGetRuleContext(0, ConditionsContext);
	}
	constructor(ctx: SetContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterWholeCell) {
			listener.enterWholeCell(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitWholeCell) {
			listener.exitWholeCell(this);
		}
	}
}
export class CellPairContext extends SetContext {
	public CELL(): TerminalNode[];
	public CELL(i: number): TerminalNode;
	public CELL(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(TodoLangGrammarParser.CELL);
		} else {
			return this.getToken(TodoLangGrammarParser.CELL, i);
		}
	}
	public COLON(): TerminalNode { return this.getToken(TodoLangGrammarParser.COLON, 0); }
	constructor(ctx: SetContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterCellPair) {
			listener.enterCellPair(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitCellPair) {
			listener.exitCellPair(this);
		}
	}
}
export class SingleCellConditionContext extends SetContext {
	public CELL(): TerminalNode { return this.getToken(TodoLangGrammarParser.CELL, 0); }
	public conditions(): ConditionsContext {
		return this.getRuleContext(0, ConditionsContext);
	}
	constructor(ctx: SetContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterSingleCellCondition) {
			listener.enterSingleCellCondition(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitSingleCellCondition) {
			listener.exitSingleCellCondition(this);
		}
	}
}
export class SingleCellCoordinateContext extends SetContext {
	public CELL(): TerminalNode { return this.getToken(TodoLangGrammarParser.CELL, 0); }
	public cellCoordinate(): CellCoordinateContext {
		return this.getRuleContext(0, CellCoordinateContext);
	}
	constructor(ctx: SetContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterSingleCellCoordinate) {
			listener.enterSingleCellCoordinate(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitSingleCellCoordinate) {
			listener.exitSingleCellCoordinate(this);
		}
	}
}
export class CellCoordinateConditionContext extends SetContext {
	public CELL(): TerminalNode { return this.getToken(TodoLangGrammarParser.CELL, 0); }
	public cellCoordinate(): CellCoordinateContext {
		return this.getRuleContext(0, CellCoordinateContext);
	}
	public conditions(): ConditionsContext {
		return this.getRuleContext(0, ConditionsContext);
	}
	constructor(ctx: SetContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterCellCoordinateCondition) {
			listener.enterCellCoordinateCondition(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitCellCoordinateCondition) {
			listener.exitCellCoordinateCondition(this);
		}
	}
}
export class RangeContext extends SetContext {
	public set(): SetContext[];
	public set(i: number): SetContext;
	public set(i?: number): SetContext | SetContext[] {
		if (i === undefined) {
			return this.getRuleContexts(SetContext);
		} else {
			return this.getRuleContext(i, SetContext);
		}
	}
	constructor(ctx: SetContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterRange) {
			listener.enterRange(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitRange) {
			listener.exitRange(this);
		}
	}
}


export class CellCoordinateContext extends ParserRuleContext {
	public coordinateLeft(): CoordinateLeftContext | undefined {
		return this.tryGetRuleContext(0, CoordinateLeftContext);
	}
	public coordinateTop(): CoordinateTopContext | undefined {
		return this.tryGetRuleContext(0, CoordinateTopContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_cellCoordinate; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterCellCoordinate) {
			listener.enterCellCoordinate(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitCellCoordinate) {
			listener.exitCellCoordinate(this);
		}
	}
}


export class CoordinateLeftContext extends ParserRuleContext {
	public coordinate(): CoordinateContext {
		return this.getRuleContext(0, CoordinateContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_coordinateLeft; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterCoordinateLeft) {
			listener.enterCoordinateLeft(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitCoordinateLeft) {
			listener.exitCoordinateLeft(this);
		}
	}
}


export class CoordinateTopContext extends ParserRuleContext {
	public coordinate(): CoordinateContext {
		return this.getRuleContext(0, CoordinateContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_coordinateTop; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterCoordinateTop) {
			listener.enterCoordinateTop(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitCoordinateTop) {
			listener.exitCoordinateTop(this);
		}
	}
}


export class CoordinateContext extends ParserRuleContext {
	public cellIndicator(): CellIndicatorContext[];
	public cellIndicator(i: number): CellIndicatorContext;
	public cellIndicator(i?: number): CellIndicatorContext | CellIndicatorContext[] {
		if (i === undefined) {
			return this.getRuleContexts(CellIndicatorContext);
		} else {
			return this.getRuleContext(i, CellIndicatorContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(TodoLangGrammarParser.COMMA);
		} else {
			return this.getToken(TodoLangGrammarParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_coordinate; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterCoordinate) {
			listener.enterCoordinate(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitCoordinate) {
			listener.exitCoordinate(this);
		}
	}
}


export class CellIndicatorContext extends ParserRuleContext {
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_cellIndicator; }
	public copyFrom(ctx: CellIndicatorContext): void {
		super.copyFrom(ctx);
	}
}
export class RelativeContext extends CellIndicatorContext {
	public CELL(): TerminalNode { return this.getToken(TodoLangGrammarParser.CELL, 0); }
	constructor(ctx: CellIndicatorContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterRelative) {
			listener.enterRelative(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitRelative) {
			listener.exitRelative(this);
		}
	}
}
export class AbsoluteContext extends CellIndicatorContext {
	public CELL(): TerminalNode { return this.getToken(TodoLangGrammarParser.CELL, 0); }
	public COLON(): TerminalNode { return this.getToken(TodoLangGrammarParser.COLON, 0); }
	public INT(): TerminalNode { return this.getToken(TodoLangGrammarParser.INT, 0); }
	public NOT(): TerminalNode | undefined { return this.tryGetToken(TodoLangGrammarParser.NOT, 0); }
	constructor(ctx: CellIndicatorContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterAbsolute) {
			listener.enterAbsolute(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitAbsolute) {
			listener.exitAbsolute(this);
		}
	}
}


export class ConditionsContext extends ParserRuleContext {
	public condition(): ConditionContext[];
	public condition(i: number): ConditionContext;
	public condition(i?: number): ConditionContext | ConditionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ConditionContext);
		} else {
			return this.getRuleContext(i, ConditionContext);
		}
	}
	public join(): JoinContext[];
	public join(i: number): JoinContext;
	public join(i?: number): JoinContext | JoinContext[] {
		if (i === undefined) {
			return this.getRuleContexts(JoinContext);
		} else {
			return this.getRuleContext(i, JoinContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_conditions; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterConditions) {
			listener.enterConditions(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitConditions) {
			listener.exitConditions(this);
		}
	}
}


export class ConditionContext extends ParserRuleContext {
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_condition; }
	public copyFrom(ctx: ConditionContext): void {
		super.copyFrom(ctx);
	}
}
export class CellNameExprConditionContext extends ConditionContext {
	public CELL(): TerminalNode { return this.getToken(TodoLangGrammarParser.CELL, 0); }
	public OP(): TerminalNode { return this.getToken(TodoLangGrammarParser.OP, 0); }
	public expr(): ExprContext {
		return this.getRuleContext(0, ExprContext);
	}
	constructor(ctx: ConditionContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterCellNameExprCondition) {
			listener.enterCellNameExprCondition(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitCellNameExprCondition) {
			listener.exitCellNameExprCondition(this);
		}
	}
}
export class PropertyConditionContext extends ConditionContext {
	public property(): PropertyContext {
		return this.getRuleContext(0, PropertyContext);
	}
	public OP(): TerminalNode { return this.getToken(TodoLangGrammarParser.OP, 0); }
	public expr(): ExprContext {
		return this.getRuleContext(0, ExprContext);
	}
	constructor(ctx: ConditionContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterPropertyCondition) {
			listener.enterPropertyCondition(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitPropertyCondition) {
			listener.exitPropertyCondition(this);
		}
	}
}
export class CurrentValueConditionContext extends ConditionContext {
	public currentValue(): CurrentValueContext {
		return this.getRuleContext(0, CurrentValueContext);
	}
	public OP(): TerminalNode { return this.getToken(TodoLangGrammarParser.OP, 0); }
	public expr(): ExprContext {
		return this.getRuleContext(0, ExprContext);
	}
	constructor(ctx: ConditionContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterCurrentValueCondition) {
			listener.enterCurrentValueCondition(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitCurrentValueCondition) {
			listener.exitCurrentValueCondition(this);
		}
	}
}
export class ExprConditionContext extends ConditionContext {
	public expr(): ExprContext[];
	public expr(i: number): ExprContext;
	public expr(i?: number): ExprContext | ExprContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExprContext);
		} else {
			return this.getRuleContext(i, ExprContext);
		}
	}
	public OP(): TerminalNode { return this.getToken(TodoLangGrammarParser.OP, 0); }
	constructor(ctx: ConditionContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterExprCondition) {
			listener.enterExprCondition(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitExprCondition) {
			listener.exitExprCondition(this);
		}
	}
}


export class PropertyContext extends ParserRuleContext {
	public IDEN(): TerminalNode | undefined { return this.tryGetToken(TodoLangGrammarParser.IDEN, 0); }
	public COLUMN(): TerminalNode | undefined { return this.tryGetToken(TodoLangGrammarParser.COLUMN, 0); }
	public property(): PropertyContext[];
	public property(i: number): PropertyContext;
	public property(i?: number): PropertyContext | PropertyContext[] {
		if (i === undefined) {
			return this.getRuleContexts(PropertyContext);
		} else {
			return this.getRuleContext(i, PropertyContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_property; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterProperty) {
			listener.enterProperty(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitProperty) {
			listener.exitProperty(this);
		}
	}
}


export class CurrentValueContext extends ParserRuleContext {
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_currentValue; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterCurrentValue) {
			listener.enterCurrentValue(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitCurrentValue) {
			listener.exitCurrentValue(this);
		}
	}
}


export class SimpleValueContext extends ParserRuleContext {
	public INT(): TerminalNode | undefined { return this.tryGetToken(TodoLangGrammarParser.INT, 0); }
	public NUMBER(): TerminalNode | undefined { return this.tryGetToken(TodoLangGrammarParser.NUMBER, 0); }
	public STRING(): TerminalNode | undefined { return this.tryGetToken(TodoLangGrammarParser.STRING, 0); }
	public BOOLEAN(): TerminalNode | undefined { return this.tryGetToken(TodoLangGrammarParser.BOOLEAN, 0); }
	public NULL(): TerminalNode | undefined { return this.tryGetToken(TodoLangGrammarParser.NULL, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_simpleValue; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterSimpleValue) {
			listener.enterSimpleValue(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitSimpleValue) {
			listener.exitSimpleValue(this);
		}
	}
}


export class JoinContext extends ParserRuleContext {
	public AND(): TerminalNode | undefined { return this.tryGetToken(TodoLangGrammarParser.AND, 0); }
	public OR(): TerminalNode | undefined { return this.tryGetToken(TodoLangGrammarParser.OR, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_join; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterJoin) {
			listener.enterJoin(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitJoin) {
			listener.exitJoin(this);
		}
	}
}


export class AggregateContext extends ParserRuleContext {
	public IDEN(): TerminalNode { return this.getToken(TodoLangGrammarParser.IDEN, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return TodoLangGrammarParser.RULE_aggregate; }
	// @Override
	public enterRule(listener: TodoLangGrammarListener): void {
		if (listener.enterAggregate) {
			listener.enterAggregate(this);
		}
	}
	// @Override
	public exitRule(listener: TodoLangGrammarListener): void {
		if (listener.exitAggregate) {
			listener.exitAggregate(this);
		}
	}
}


